reference gets lost >before< data table gets closed

[#1]

I just noticed that a symbol reference to a data table gets lost already before this dialog opens:

TS-00076052

Even if you click on Cancel, the reference is lost:

[#2]

Yeah, I've run into this many times.  JSL is nothing if not inconsistent and annoying!

[#3]

Fortunately, JSL (an Jmp) is much more than that

there is sooo much on the good side of the scale.

But there are definitely "some" trap doors in Jmp and JSL.

For part of them, I learned from Jmp support that they are "as designed". Unfortunately, there is no "map" which tells Jmp users  which carpets and corners to avoid

For the really big traps, I decided to start collecting:
Caution: Places where Jmp does something unexpected 

Tips and Tricks - best practice with JMP/JSL 

For the small ones, I just created this post:
Tiny Traps in Jmp and JSL 
It will be for the tiny Issues like a lost reference - I guess there are hundreds? 

Instead of a community post, it would be much easier for Jmp support to provide this list of known traps that are 1) "as designed", 2) too tiny to get fixed or: 3) to big to get fixed right away.
Perhaps with an option for users to vote and discuss?
Actually, similar to the wish list - but with Jmp support filling the list; and not a list of cool, new features, but a list with known traps. hm, this doesn't sound appealing, right? At first place, nothing that you set up to attract new users ...
But for current Jmp users it could help a lot to document known traps.

And for future Jmp users?

In general: Current users should be "picky" enough to get annoying traps removed.
What sounds like "complaining" has to be understood as: making a good thing amazing.
(or with other words: making something great less "inconsistent and annoying" 
So that all future users of Jmp can enjoy the power of the program without such traps.

[#4]

Just to be clear -- I like JSL and spend about 50 hours a week with it.  But it has also brough me the most frustration of any programming language that I've used, although most of that frustration was learning how to deal with a dynamically scoped language.

And the inconsistent / annoying things in JSL are usually a result of some amount of backwards-compatibility, such as Summarize()

Names Default To Here( 1 );
Open( "$SAMPLE_DATA/Big Class.jmp" );
Summarize( exg = By( :sex ), exm = Mean( :height ) );
Eval List( {exg, Round( exm, 1 )} );

That is a function that does the funky with it's arguments.

Also, why do platforms get a Report() message, but graph builder needs a Report() function call:

Names Default To Here( 1 );
dt = Open( "$SAMPLE_DATA/Big Class.jmp" );
gbp = Graph Builder( Variables( X( :height ), Y( :weight ) ), Elements( Points( X, Y ), Smoother( X, Y ) ) );
gb = Report( gbp )[Graph Builder Box( 1 )];

vs.

Names Default To Here( 1 );
dt = Open( "$SAMPLE_DATA/Grocery Purchases.jmp" );
obj = dt << Association Analysis( Item( :Product ), ID( :Customer ID ) );
r = obj << Report;
t = r[Outline Box( 1 )] << Get Title;
Show( t );

[#5]

like many of us - no analysis anymore without Jmp

The syntax of Summarize is special, right
Are there more functions like this?
Nevertheless, a quite convenient way to provide the symbols AND the purpose and then get them filled with value /values.

By the way, quite flexible as well: one can even specify separately  multiple bys - and  it gets slightly more unexpected

Names Default To Here( 1 );
Open( "$SAMPLE_DATA/Big Class.jmp" );
//Summarize( sx = By( :sex , :age), exm = Mean( :height ) );
Summarize( sx = By( :sex ), ag= By(:age), exm = Mean( :height ) );
Show(sx); // -> list of ALL groupBy
Show(ag); // same list

---

@ErraticAttack wrote:

... why do platforms get a Report() message, but graph builder needs a Report() function call:

This sound a bit similar to my question:

why are there so many messages that I can send to a data table but not dt << n rows()

another candidate for Collection of "funny" Jmp newbie questions ?

If there was a difference before, now it's possible to use either of the 2 approaches:

obj << Report;
Report(obj);

Could be treated as a sign for the effort that was/is/will be spent to make Jmp less inconsistent