I have a perspective that might help cover topics you raised which
haven’t been covered much, yet, in this thread:

APL has had a lot of implementations, with literally dozens of
different kinds of character set support. J, in contrast, is strictly
ACII based (though also capable of representing other character sets,
with some unicode support).

Types bring in a lot of other issues (along with a community habit of
declaring things “wrong” without much effort).  It’s tempting to ask
about what type of types you are asking about, but that’s a very deep
rabbit hole...

I have worked with an APL subset compiler (which used an ML-like type
system).  You could build something like that for J, if you were
willing to invest the time (maybe a few years to get something basic
that’s reliable, distributable and documented? Maybe less if this was
not your first time building such a thing.)

J’s native type system is rather like living inside a monadic type
system, in the sense of having eliminated everything else: Basically,
everything is an array.  This breaks down into four different
subtypes, each with different syntax rules: noun, verb, adverb, and
conjunction.  And nouns have about 30 different element types (along
with a somewhat arbitrary sequence of dimensions - in some type
systems, array dimension is a part of the "type").

J's typing is "weak" in the sense that types are treated as a
necessary evil, and support for them is minimal with many traditional
constructs left out.  Necessary because they give us abstractions to
link math concepts to hardware features.  Evil because they tend to
prevent useful work and at the same time they tend to enforce
inaccurate abstractions.

That said, J has great support for dynamic linking, and you can
incorporate code written in other languages rather easily - if the
language supports dynamic link libraries (though you have to have a
workflow which can survive the hazards of that kind of work, which can
include frequent crashes and reboots).

I hope this helps. Please let us know if you need examples on any of
these issues.

Thanks,

-- 
Raul

On Wednesday, May 16, 2018, jane dalley <jane.dal...@outlook.com> wrote:
>
> This is my first post; my hope is this is an appropriate question.
>
> My knowledge of APL and J is very limited so my expectation is a simple 
> answer that is within my limited ability to grasp.
>
> Examples:
>
> How similar are both APL and J?
>
> To the best of my recollection APL could be written with EBCDIC so why J?
>
> Can APL do everything J can do and visa versa?
>
> Can APL and J be forced to be strongly typed?
>
> Are APL and J capable of being Object Oriented like C++ or C#?
>
> Would one view J as a superset of APL?
>
> Are J and APL more than niche languages?
>
> Sorry if any of these questions are perceived to be offensive, probably they 
> have been asked many times before.
>
> Sorry also if these questions are deemed silly such as a toddler might ask.
>
> Regards,
>
> Jane the novice of J
>
>
>
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

Reply via email to