1.2.0 Event Handler Caching, your input is required?

This is more of an announcement of the upcoming 1.2.0 features.

Since event handler caching will be instilled into the framework, the
performance is dramatic. It actually, does not make sense to be
creating event handlers for each request. So version 1.2.0 will be the
last version to support un-cached handlers. The versions after 1.2.0
will have caching of handlers by default. I see no benefit of
uncaching the handlers. And they can easily be recreated by using

So. Since event handler caching actually changes A LOT in event
execution. The methods will receive the request collection object,
instead of the handler beign injected with it at creation. What does
this imply? Well, mainly the 'rc' scope will become deprecated. You
can keep it, however, you must var scope it locally.


var rc = arguments.oRC (or whatever the argument is named, still

Please keep this in mind.

There will also be some changes due to your suggestions, to have a way
to distinguish framework methods from local ones. Most likely, the
oRC object will also hold some extra methods to invoke some external
commands. This is still in the definition process. I guess an example
would be on how to run an event from within an event. Example code:

oRC.getEventManager().runEvent("event", oRC);

I will then run the event and pass in the oRC as you see above.

Please give me your input on these upcoming features. The event
handler caching is a totally different execution process and some
previous version code will have to be altered, but it is for the
common good. You will see the execution differences. You will never
think you are running your application in a framework.

Please give me your input.


At the moment i happy with way you are going to make these changes in
These changes provide more flexibility and more clean way to calls
things and also quite differenciate local methods and framework
Luis you are doing a really great job and I hope to see these things
in action.


I think having the OPTION to do event handler caching is good, as long
as the framework provides a way of turning it off, so that the
framework does not impose requirements on my environment (i.e. like
needing to have the session scope activated). Even further, I would
like Coldbox to give me the ability to select WHERE do I want to cache
the event handlers: application or session, (or -getting a little
funky here - to client scope via serialization/deserialization), since
I could take advantage of this feature to apply very different
architectures to my design of event handlers.

Another thing I think should be clarified a bit is why I would need to
go through the request collection to execute an event or event perform
an action; as far as I understood, the request collection was just
that, a collection of values that was accessible to all elements of
the request (event handler, layout, view)

Also, this is a minor thing, but having an argument with a name as
cryptic as "orc" or "oRC" is not a good idea.