World: r3wp

if we can't have full fledget debugger, then we are crap :-)

maybe we could have a FUNC idiom that doesn't protect anything for 
debugging purposes ?

right now, the only thing I can't "anamonitor" is a function body. 
 I can get that function's body, but can't resolve what the functions 
*it* contains really do.  


all the rest works pretty much as is did, actually it works better, 
since we have real inspection routines now.

If we want to be able to use R3 to show third-party content, then 
full debugging without the original source won't be allowed. It's 
the way of the world now.

brianh, we can't debug *with* the source right now  :-)

Ok, but for our own work, we still need to do so.

hehe

I can (and do) want the world to be open and all information to be 
free, but it's just not the way the world is now.

huh? BrianH this has nothing to do with 3rd party.  we can't debug 
functions of any kind right now.  with source, hot chocolate or from 
the movie wizard of Oz.

And you can debug if you have the source. However, some of the process 
will go through your head, in the form of knowledge of where functions 
are defined. Or you can take portions of the source without the protections 
and debug them independently.

debugging implies that a tool shows you that information... the name 
of a function or word is irrelevant in REBOL.

If you need to debug your own source, you can do so. You just can't 
use a debugger to get past the protections.

for example, if I want to do a real time debugger which shows me 
the current content of the block which is being stepped through by 
a loop... 

I can't since I can't get access to the block which is being used 
by that function...

Yes Maximn, to do runtime debugging, we must be allowed to construct 
observable functions

There are other methods of debugging at runtime if you have the source. 
Heck, even good old print statement debugging would work.

it could be simulated with a special mezz. A function which executes 
an indirect DO on one code block instead of building a function.

So that the code block could still be inspected by a debuging tool.

hum... maybe a way to build a context when building a function, with 
the index of each member of the body block mapped out to its original 
source.

yep it should work

then the debugger could inspect the context instead.

Right, and that kind of thing works now. But allowing a debugger 
to get past the protections just isn't going to happen. We don't 
have a way to know at runtime which person needs to be asked for 
permission to break past a protection like that. Since it certainly 
isn't the user.

you will just have to furnish mezzs to replace the standard, func, 
funco and funct

we could be able to do this by switching to a "debug" version of 
the various func creating mezz

Yes, and replace those functions before the system is protected to 
support the reset.

we could even make those functions able to trigger events based on 
"break points"  then listen on those events in a normal event loop.

so the debugger actually adds a line of code where the break should 
happen... then rebuilds the body block it executes when its called.

They could even be trace events.

since the external function isn't replaced, its transparent .

Pekr - "if we can't have full fledged debugger, then we are crap 
:-)"

Agreed, though maybe not complete crap.


Brian - "Heck, even good old print statement debugging would work."

Agreed, to an extent.

Brian - "They could even be trace events."


Ahhh, joy. What can we learn from DTrace, and what should modern 
debugging look like? I have, at times, ached for the ability to step-trace 
and set break and watch points in REBOL. At the same time, I don't 
want to be myopic and focus on how we debugged in the past.


What are the best ways to debug the things we're supposed to build 
with REBOL? And can we hope for mechanisms to let us debug things 
outside what RT says REBOL is targeted at?

using replacement function builders we could, in theory, completely 
control how execution occurs.  this would be at some speed cost and 
possibly not 100% transparent.


but setting break points and real-time value watching is definitely 
in the realms of possibility.

I just don't want to preclude the use of R3 in the biggest industry: 
content delivery and presentation.

Or for that matter, any secure client systems. Most cryptographic 
security is based on secrets. If we can't keep secrets, we can't 
be used for those purposes.

Other secure systems are debuggable

As is R3, just using different methods. You might notice that DTrace 
doesn't allow you to read the iTunes process on OSX.

Not everyone is on the board of Disney

Secure systems can be debuggable. But security comes first.

Especially when there are other methods for debugging that don't 
require breaking security.

Are all the "^M"s below because of datatypes not implemented yet 
or is this a bug? I'd expected READ/STRING to not only TO STRING!, 
but to DELINE the data read.

>> sql: read/string clipboard://
== {create table scans (^M
               id     serial primary key,^M
               date   date not null,^M
               time   time(3) not null,^M
               job    integer not null, ^M
               branch integer, ^M
               ean    char(13) not null,^M
               box    integer^M
          )}

IIRC, READ at one point only returned the data read as a binary stream, 
forcing you to DELINE TO STRING! READ ... because of the transition 
to UTF-8, but /STRING was added back later. Found nothing in the 
change log, though.

How can I remove key form map! ?

set it to none

Hm, it's easier than I though :) Thanks

Any comment onto R3 now displaying security dialog each time it starts? 
Do we have some non-standard exe being generated by hostkit? This 
symptome is not happening with A99 IIRC ...

The clipboard:// type returns a string without line ending conversion, 
at the moment. It hasn't been updated since before the /string refinement 
was added. It's a platform-specific bug.

I've got this unexpected R3 behaviour (it's the core of the LDS issue 
mentioned in [Testing and Tools]

    f: func [] [error? try [return 1] return 2]
    f
    == 2   ;; r3 does this....despite no error
    == 1   ;; r2 does this...as expected

Any ideas, thanks!

Yes, this is CC #771

Carl intents to correct it, but it will not be in A108

Now you have to circumvent it, at the cost of having longer code. 
I suppose, that the not simplified code is more like:


f: func [] [error? try [do-something return 1] return 2], which can 
be transformed to:

f: func [] [return either error? try [do-something] [1] [2]]

Thanks...Glad to know there are work-arounds.

Sure, this is not that hard to circumvent, but it comes at the cost 
of needing to "reorganize" the code