World: r3wp

When profiling traversal operations, I have experienced skewed results.

Interesting. Examples?

Well, my get-block function is an example.  I used it on a series 
of block data and get different results that don't seem to jive with 
my expectations.

Some more complex reads actually resulted in better performance then 
less complex reads.

Are you talking about file access?

I had done a test where I read a small 5000 record file and compared 
to a 100000 record file and the 100000 record file proviled better 
performance than the smaller one.

After the file read.

Sounds like cache is a factor here.

http://www.tretbase.com/forum/viewtopic.php?f=8&t=30#p131

That function.

Cache is definately a factor in those type of operations.

Looks like parse could help with the speed, but it might be harder 
to get it right.

I started to go that route but started getting bad performance so 
I went this route utilizing find.

It was most likely an implementation detail as find I assume uses 
parse.

Nope. FIND is faster than PARSE, but PARSE is faster than FIND with 
WHILE.

And while is slower than until and foreach.  It gets complicated.

The trick is that it is harder to write and optimize parse code, 
so it can get really slow without you understanding why. The downside.

It gets complicated.

 It gets more complicated with R3, since R3 has made most of the previously 
 mezzanine loop functions native. This means that FORALL and FORSKIP 
 are faster than FOREACH in R3, while they are much slower in R2.

LOOP is still the fastest though :)

Paul, it looks like that ANY+ function has potential, with some tweaks.

Yeah, that is my hope that some of those spark some interests.  Feel 
free to add comments on the site as well or updates to the functions 
that you feel could be more beneficial.  The goal of that thread 
was really to open the discussion of mezzanines and how to improve 
them.

ALTME is not the best medium for that type of  effort.  The forum 
remains with some clean code and examples.

Don't forget to bring up the most general of your library functions 
that would get the most use in the Idioms group.

My favorite one there is the evals function.

Your talking about on RebDev?

Yeah. This kind of discussion is the whole point of R3 chat.

RebDev is not user-friendly enough for me yet.

I know how to move in it but it is just a pain compared to alternate 
methods.

I was wondering why you weren't invollving yourself in the conversation. 
Functionally it is much better than AltME, though the UI sucks.

Still some missing features though.

In theory the new logic! for R3 will solve the same problem that 
EVALS solves, but logic! flags doesn't work too well yet.

Really, that is it.  I think there would be much more involvement 
if the UI was much better.  I think the problem is that Carl is still 
in honeymoon stage with RebDev and doesn't yet understand how much 
work is still really needed to get it embraced.  At this point I 
think ALTME is far better medium than RebDev.

AltME is horrible for useful, focused discussions. No threading, 
no subtopics, no moderation. R3 chat is already better for that.

Evals could be improved dramatically to be a very cool function.

Well in a sense ALTME has as much threading as RebDev by the means 
of groups.

I still think a better solution would be a darknet forum that way 
Carl doesn't have to worry about spammers.

Not really. The lack of moderation is the real killer though - you 
can't move or delete messages when they are off-topic in AltME.

Yeah but that can be resolved by careful inclusion of the darknet 
members.

In theory, the ranking of R3 chat can be used to get rid of spammers.

Is 'dirize/off an option?

Chris, yes, but that would double the code of DIRIZE and add refinement 
checking overhead to every call, so the effect is worse.

Assuming 'dirize asserts a state on a file (dirized or not).

It's one logic check vs. an extra function.

Brian, that is the way I like to see you thinking.

Dirize only works on the file! value, not the file referred to by 
the file! value. It would be adding one logic check plus the entire 
contents of an extra function. The code added would actually be more.

Always think of the impact of a function regardless of size when 
it is done in a large loop.  All of those extra checks add up.

Yup. That's why they have me work on mezzanines :)

hehe

It's also one less function to learn.

Adding an option to a function that changes its behavior makes it 
harder to learn than a seperate function. The only thing you have 
to remember with a new function is the name. You have to do refinement 
processing in your head too, remember :)