Dieter Ensslen wrote:
> another impressive and kind opus!! The first part is great, the
> first and easier part sinks in, the latter parts get too technical
> for now.
I only put the latter part (I'm referring to the suggestions about J
working in conjunction with other languages and about invoking J with a
command line statement--maybe you're referring to something else) into
my message to indicate that I was able to do some of this stuff for my
own needs AFTER ONLY A YEAR OR TWO of working with J and asking
programming questions in the Programming Forum. That "year or two"
refers, on average, to maybe an hour or two a couple of times a week.
Until I retired last summer, I obviously had my regular job to do, too.
However, some of the statistical needs I had in my job related to J,
and so there was both a need and opportunity to learn J as part of what
I needed to do on the job. I mention all of this because what may seem
"too technical for now" WILL get better as you practice programming in
J. Besides my former work needs, I also had a hobby of analyzing stock
market action, and so this became a home avenue of learning and
applying J in "real use" circumstances. (I'm a single widower, my
children having married with families of their own and no longer living
at home--so, in my case, "family life" wasn't something that I had to
be concerned with. I can spend as much or as little time with J as I
choose. Your case may be different.)
As I said in my previous message: "As a beginner with J, I was finally
able to figure out how to do some of this stuff--with lots of help from
the people in these forums--AND YOU CAN, TOO. But you've got to work
with J itself ... take the time to really learn J. J takes a bit of
effort to learn, but it's effort well spent!" Note my added emphasis
this time around. *YOU* can do it! But you do have to "play" with J
("hands on") to really learn it--you can't just read about it or listen
to others talk about it here. You can't learn to drive a car just by
reading about it--experiencing it (and learning from experience) is the
key. The same goes for J. As a beginner, anything you do with J won't
crash the computer (well, to quote Gilbert & Sullivan, "hardly ever"!
;) ). I admit that J's error messages are VERY cryptic for a beginner,
but that's what these forums are for--you are not left alone on your
own as an orphan to learn the language. J won't bite you. And, after
a little acquaintance with it, you'll see how interesting and how much
fun it is to "fiddle around with" data.
> then again, once you start talking verbs and nouns and all that
> other language grammar stuff, and monads and dyads i start thinking
> of the triads. sorry
I haven't the slightest idea what you're talking about when you speak
of "the triads".
Though it is not very often mentioned in the J community, J is NOT only
for math and computer programming geeks. Based on what he wrote, I'm
sure that Ken Iverson (the "inventor" of J--and APL, for that matter)
could envision applications in the humanities as well. (If you have an
interest along this line, I'd highly recommend taking a look at Cliff
Reiter's book "Fractals, Visualization, and J".)
I mention this because Ken Iverson deliberately avoided computer jargon
("computerese") so as to encourage the general use of J in all sorts of
applications, both in the sciences AND in the humanities. He decided
to use the "natural" terminology of "natural language". That's where
the terms verb, noun, adverb, conjunction, gerund, and so on, come
from. In spoken/written/read language, verbs act upon nouns. In "I
eat food", "eat" is the action I do with "food". The same applies to
the other parts of speech, such as adverbs modifying the action that
verbs do. I hope you get the idea; it's something you learned already
back in elementary school.
In J, a "noun" is generally the data you're dealing with: the data you
start with, the "in process" data as it's being manipulated, and the
data you end up with--all of these are nouns. A "verb" is some
process, action on, or manipulation of data (a noun), such as sorting,
reversing, selecting, and the like. It's all a matter of thinking
through the steps of how I get from the starting data to the data I
want at the end. (In many respects, it's like solving a puzzle.)
That's why one of Ken Iverson's most important papers is entitled,
"Notation as a Tool of Thought". J helps you to see--and especially to
think through--the "big picture". It takes care of all the nitty-
gritty little stuff you have to worry about in other computer
languages. The second-biggest hurdle a beginner usually has to
overcome with learning J is to avoid thinking about how to code loops--
it's built into the language!
You're probably asking, "If that's the second-biggest hurdle for a
beginner, what's the biggest hurdle?" This is slightly a "trick"
question, because it depends on whether or not you're coming from an
APL background. Assuming that you, like me, have a "traditional"
programming background, the biggest hurdle (in my opinion) is thinking
about a set of data *AS A WHOLE* and not as individual, discrete items.
This is the true power of J! The verbs (such as sorting, reversing,
etc.) act on the whole set of data AT ONCE, not requiring explicit (and
often nested) loops to deal with individual items--although you COULD
write explicit loops if you wanted to (and, to be sure, in some cases
you NEED to write explicit loops). I sometimes think that, the longer
one has worked with explicit and nested loops, the longer it takes to
UNLEARN that concept when working with J. Although I'm getting better
at it, even after two years I still struggle with it.
> someone mentioned exe recently too as well as ijs and ijx.
The "exe" refers to the command line statements I mentioned in my
previous message about your concerns. Essentially, it means that, at a
command line prompt ("C:\>" in Windows, for example), you'd enter the
name of the executable file ("j.exe") followed by a series of
arguments, just like you would in any MS-DOS command with arguments or
with any DOS software needing starting arguments. You'd need to know
the correct J format for arguments, of course, but the principle is the
same. Until you get more familiar with J (*AND* have a need for this),
I'd suggest that, as a beginner, you stick with the "ijs" and "ijx"
windows.
> Yes, it is nice to have a clean ijs sheet with successful programs
> and comments.
What the "ijs" sheet looks like is completely up to you: you can have
it "clean" or you can have it "messy" (that is, busy-looking). The
important thing, of course, is whether or not you've indicated enough
structure (including white space) and information (such as comments) so
that 6-12 months from now you could look at your program and know
what's going on and why you did certain things a certain way. But
this, of course, applies to *ALL* of your programs in *ANY* programming
language! (At least those you want to use more than once! ;) )
In a sense, each "ijs" file is your "program storage" for each
application you write, big or small. This is the beginner outlook,
though. If you really get serious and develop very large, complex
programs with perhaps many subprograms, then J has other facilities for
managing all of those. (I'm nowhere near that stage yet!)
> (philosophically J just seems to be bucking the trend towards easier
> and easier communication a la wolfram | alpha, and the 10 odd year
> old trend towards cas, and the easy play of i pad apps, as well as
> my decades old mentors' to go with high powered easy to communicate
> with high level languages where it is easy to determine what is
> going on).
For *ANY* programming language, it's the job of the programmer to do
all of the really HARD stuff behind the scenes so that it is EASY for
the end user. The programming stuff doesn't necessarily have to be
ultra easy--it just has to have all the necessary tools to be able to
do what you want. J has all of the necessary tools, and, with clear
thinking, you can do nearly anything you want in a relatively
straightforward manner. Anybody can think that using a hammer is
simple, but a carpenter has to learn how to use that hammer to
efficiently and effectively build a house that won't fall over!
Wolfram|Alpha?? Get real! As a former librarian, I know that
search/answer engines are getting better, but your local public
librarian is far better in general at finding what you're seeking--and
he/she is FREE! It doesn't take a lot of computer brain power to
answer FACTUAL questions, but most of life is concerned with "fuzzy"
things like comparisons, quality, value, and the like. Those things
depend upon YOU individually, not on some conglomerate idea of what
"people" in general might be looking for. Wolfram|Alpha and its ilk
depend upon selling technological glitz and "sizzle" ("it sure looks
cool, doesn't it?"). Would NASA trust Wolfram|Alpha and its ilk for
guidance regarding sending astronauts into space? Would you trust
Wolfram|Alpha and its ilk to inform the robot performing surgery on
you?
You keep mentioning CAS. I do NOT feel that CAS is the "be all and end
all" of computer programming. (It might relate to a very small part of
mathematical programming, but that's hardly "general" programming.)
Would you kindly inform me how CAS is going to help me write a musical
composition or artistically modify a graphic image? J is a language
that helps me do all that and far, far more. Can CAS do all that, too?
Your emphasis on the iThis and the iThat is starting to sound like a
broken record. The J community CANNOT do a thing about those gizmos.
Apple won't permit any kind of general programming application to run
on its designed equipment--it will permit only individual apps that do
ONE AND ONLY ONE THING to run on its equipment. "Wishing don't make it
so." As I've said previously, if you don't like it, bug Steve Jobs,
not the J community. This is a sad situation: as I hope that you've
noticed, you're losing some of your potentially most helpful people
through a seeming resistance (based on what you say) to actually
sitting down and learning J and through a seemingly constant repetition
of opinion, regardless of how people have tried to understand and help
you.
Regarding "high level languages where it is easy to determine what is
going on", I presume that every computer language you've ever learned
in the past required at least a tiny amount of time and effort on your
part to learn, and I presume that the computer languages that you're
good at probably were those that you spent a lot of time and effort
with. The same goes for J: the more time and effort you spend with it,
the "easier" it WILL get. (Of course, if you don't touch the language,
it will remain just a bunch of "Martian" symbols with no meaning to
you.) I feel MUCH more comfortable now with J than I did when I first
started. As a matter of fact, for much of the programming that I do, I
now turn to J first, even though BASIC-style languages were my first-
choice, "native" computer programming languages in the past.
> (My comment: the BASIC of 1982 is easy, and the hope was that it
> would have gotten easier and yet more powerful and faster with still
> more functions, color, and a big display.)
VB6 was the historical high point in BASIC, capable of everything you
mentioned--and more. (I realize there are several other BASIC's out
there which might disagree with that, but the Microsoft BASIC market
share carried a lot of weight.)
> No question, j is intriguing ...
Yes, it is. And it's that inriguing nature that brought me to J. A
book I have was full of APL code related to computer assistance in
musical composition. When talking with a friend of mine in the early
2000's about time series and stock market research, he mentioned J, but
I didn't pick up on it
until around 2006. It was at that point, while researching what J can
do and
its historical connection with APL, that everything clicked into place.
I
could translate the APL code for musical composition into ASCII-
oriented J
instead (which I eventually hope to integrate with my synthesizers),
and I
could program my stock market research myself with powerful J commands.
And
that's how I became "hooked" on J.
I hope that you will make the effort and become "hooked", too!
Harvey
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
