• Goals

1. OpenJ project Content
2. OpenJ project goals
3. Justifications
4. Language structure
5. What should be included in core
6. Extensions
7. Maintaining compatibility
8. Legal issues
9. Documentation
10. Licensing

OpenJ project Content

1. langugage parser

2. evaluation engine

3. foreign module

4. script libraries

5. GUI module (platform-independent)

6. GUI scripts (platform-independent)

7. platform bindings for service, console and GUI (via sockets?)

Possibility of alternative platforms, compilers, libraries, GUIs be possible by having isolation levels in the source code and binding interfaces.

OpenJ is obvious and already used name. The official name of the project is OVL-J -- Open Vector Laguage. However, for brevity OpenJ is used in the following.

OpenJ project goals

The goals of openJ project is to provide portable open source implementation of

1. J programming language as defined in J Dictionary [1](reference implementation of JSoftware J -- jsj);

2. J standard library as (informally) defined by system/main contents of the existing J implemlentation;

3. J development environment for both console and windowed environments, including automated testing facility;

4. Application packages (uspecified yet, but, probably, related to volume data processing, analysis and presentation) that utilize unique J powers; (statistic, plot, database, grid)

5. Application packages that may benefit from terseness of J code; PIMs?

6. Collection of J phrases (idioms) (difference from static J Phrases is that this collection will be updated and enriched by contributors continuously);

7. Body of explorative topics (exampled by lab collection), which not just shows off J strong sides, but also educates and informs their user in matters seemingly unrelated to J;

Justifications

1. Discover, collect and create open implemention and references of array processing algorithms, thus protecting their heritage from proprietary usurpation

2. Seek performance benefits in experimentation with different implementations

3. Such implementation will provide J for platforms unsupported by jsj.

Language structure

OpenJ language will consist of core plus some optional extensions. It will be the goal of assessment stage to define which elements of original J language will be part of the core and which will be implemented as extensions. Examples of features that may be defined as extensions include extended integer arithmetic, windowed gui, calling external libraries, special-code for idioms, multiprocessor implemetation for array operations, etc. Features may depend on each other and explicit tree of dependencies must be maintained as essential part of project documentation. Different builds, depending on the requirement of the particular build may or may not include any specific feature.

Some of the listed above features are part of jsj, some are not.

The extension mechanism is also intended to serve as proving grounds for various ideas that may improve array processing capabilities of J. For example, parallel processors implementation is not part of J504 but it would be nice to try it out.

What should be included in core

• language parser

• integer arithmetic

• single byte character manipulation

• boxes

• array manipulation operations on arbitrary data

• locales

• no artificial limits (notably, recursion depth and identifier length)

Extensions

• real arithmetic

• complex arithmetic

• extended/rational arithmetic

• booleans

• (?) packed booleans

• (?) alternative arithmetics (SLI, residue, other base, other size)

• unicode

• console style user interaction

• (?) alternative locale stacks (like in Forth)

• (?) closures

• (?) assigning unicode names to verbs and adverbs to mimic APL

• calling external libraries

• windowed gui

• (?) text based gui

• (?) parallel processors implementation for array operations, alternative compilers/libraries, such as Intel or PDL

• (?) data flags (sorted?, nonnegative?, symmetric?) to allow optimisation of certain operations

• (?) dictionary (hash) operations

• (?) trees/graphs/links (together with symbols?)

• (?) prototyping (see below)

Features marked with (?) are not part of the existing J implementation. They are examples of what may be tried out in the openJ sandbox.

There should be some relatively easy way to prototype extensions in J itself. In most cases performance might suffer greatly. What I mean here is the ability to override standard operations for certain types of data and give programmer access to internal structures and hooks.

Maybe this ability should be implemented as 'prototyping' extension.

Maintaining compatibility

Extensive set of tests for each core and extension feature will be developed and maintained in order to provide a way to assess compatibility of any particular build with the existing implementation where appropriate.

Each standard library function will also be represented in testing facility to make sure that it is not broken when new feature is introduced.

Legal issues

J Dictionary is copyright by Jsoftware. Jsoftware should be contacted and begged to release it under some kind of free lisence that explicitly allows free distribution and allows modifications and derived work.

It is not clear what is the license status of J standard and developement libraries, as well as plot, grid and other applications written in J and included in J distribution.

Documentation

Each implemented language feature should be clearly marked in dictionary as belonging to core or to extension and to which particular extension (this is why J Dictionary should be allowed to be modified). Each implemented feature should be supplied with tests in mentioned above automated testing facility.

Each standard library feature should be supplemented with a complete reference, describing in sufficient detail each verb, adverb, conjunction or noun included (preferably in a form of scriptdoc or some extension of scriptdoc) and tutorial (preferably in a form of a Lab) that shows "typical use" of this feature.

(Sidenote. One of the jade subprojects: ways to turn scriptodoc and lab into nice looking printable documents. Also ever changing dictionary of OpenJ project should allow conversions into online manual and printed form.)

Licensing

OpenJ, library, applications and documentation will be distributed under some kind of unrestrictive free license. All contributors must agree to this.