I am currently okay with using 0.05 nanoseconds (not milli) for a unused
logging call (current state of performance). I am sure that monocle is
fast. But I am not sure if a callback loop to AS3 would be (even if it
might be available). And even if it would be fast, it could not be
faster than implementing a compile-time logic (as was elaborated by
adobe in their falcon blog post yesterday) as compile time is hardly
beatable.
Essentially I am proposing a system that allows compile-time filling of
blanks in the code by things the compiler might know. Especially
important for me are name and location of the caller of a method. I can
imagine other things the compiler knows of might be important for other
usages to:
XML description as provided by describeType;
class MyClass {
[Fill(data="container.xml")]
private static const asDescribed:XML;
}
For IOC it might be a high-performant way to combine that by using:
[Fill(arg="typeInfo", data="caller.type.xml")]
[Fill(arg="constr", data="caller.type.constructor")]
public function createInstance(constr:Function, typeInfo:XML) {}
Maybe the compiler flags or other compilation data might be interesting:
[Fill(data="compilation.flags")]
private static const flags:Vector.<String>;
[Fill(data="compilation.time")]
private static const compiledAt:Date;
Or maybe even custom arguments like the time when this was compiled
[Fill(data="compilation.arg.user")]
private static const compiledBy:String;
That are just some idea I have had for that. I think it would help
creating high-performance applications, especially important for mobile.
And we might not be that limited when its up to logging solutions. Some
questions still bug me:
*) How should this be named? (auto-fill, compiler-data,..)
*) What applications could that have? Is it interesting for IOC?
*) How to implement that? I would need a compiler crash-course. Are
there members who could provide mentoring?
yours
Martin.
On 20/01/2012 03:28, Omar Gonzalez wrote:
There is an incredible amount of data being passed from applications into
Monocle at what appears to be an extremely fast clip. I can't speak to what
methods they're using to accomplish that, but the speed is extraordinarily
fast for as much data as there has been in the demos. Have you looked at
the video? There is a lot of information _per frame run_ with highly
detailed information about what is running, how long it took, the phases of
the frame in which it occurred and other things that they still have not
demo'd publicly.
Either way, you're free to work on whatever you want, as is the "Apache
way", I'm just letting you know of what's coming on the horizon as it might
influence your decision, or you may not care and just do it anyway, that's
your call! :)
-omar
