Communication Throughout Application and Components

Question

Up to now my experience with Flex/AIR has been mostly small
programs, studying Flex/AIR, and the joy of contributing to this
forum.
I'm now in the middle of developing my first "real" Flex/AIR
app, in that it is tied to a quarterly goal, and over time others
in my department will actually use it.
I've broken the app into several MXML components, and there
are components that use components, that use components (several
levels of nested components).
As you might imagine, sometimes these components need to
reference variables/functions in other components, or in the main
app, and I think I've done fairly well, based on my limited
experience with this sort of thing (I'm not a programmer by trade,
but I seem to fairly sharp ???), but I can't help think things are
too tightly coupled.
Should I be trying to push the limit in communicating between
the app and the components and among the components using only
events, often custom events, entirely if possible?
I know practice makes perfect, or well, you know..., but I
want to "do it right" as much as possible now.
Thanks very much!!!
Greg

Answer 1

OK, although I am not the best at Flex, here is what I think.
"Should I be trying to push the limit in communicating
between the app and the components and among the components using
only events, often custom events, entirely if possible?"
No, well maybe or sure. It depends...
There are major segments in a Flex swf: Application, UI
views, components and controls... As well as different kinds of
events, say user gestures and system events.
And there are many design patterns that make the application
lifecycle manageable: development, testing and maintenance.
Design patterns differ in approach: some tightly couple a
view to it's controller/model. Even there the view may be active or
passive. A tightly coupled active view would simply call methods on
it's associated model/controller whereas a passive view may have
data pushed into it via bindings and injectors.
The controller may use events to access services from the
main application controller.
So it is the design structure (design pattern) that guides
one along with a consistent set of guidelines for the development:
events vs calls vs bindings vs injectors vs observers...
Consistence is the key. And a good proven design pattern that
fits your particular application needs is the key design guide:
events vs method call; passive vs active view; ...etc.
And finally, it is often a "framework" that provides the
foundation and supplies the specialized classes to ease the
implementation.
This set of articles on the "Presentation Design Pattern" is
a good read and I recommend you read it for a far better
understanding that I can offer. That is simply the Presentation
Pattern and of course there are many others like MVC.
Mate is simply a framework; a lib of tag elements that better
enables the application of your selected design pattern into the
Flex framework. It is event and injector oriented.
Well, I hope that helps.