What is the best practice in terms of communication (variable usage ann method calls) between custom components developed using mxml.
You could use Flash's built-in Event mechanism, which has no external dependencies.
http://livedocs.adobe.com/flex/3/html/help.html?content=events_01.html
You might want to implement one of the frameworks mentioned here: Flex MVC Frameworks. A proper architecture will allow you to communicate between components more easily. I use pureMVC in my current project.
Cheers.
PureMVC is pretty solid. It take a bit to get familiar with the design philosophy. But once you are set up it is pretty easy to code against and makes your project easy to grow and extend with solid MVC design principles.
The main thing about PureMVC is its concept is a concept of Notifications. You can pass around various objects in a simplified way throughout the system.
For an overview of PureMVC checkout
http://puremvc.tv
http://puremvc.org/
If you would like some more specific code examples or have specific questions let me know.
Related
I'm in the process of choosing a framework for my flex development, and one of the questions that was asked about a framework was "is this a framework or a micro-architecture"?
Can someone clarify what's the difference?
What exactly is a framework, and when can we start calling what we have a framework? I work with FlexBuilder3 (now called FlashBuilder4) and have a lot of standard things that I do for almost all projects, and components that I created for easy re-use. Some are very very small, but the benefit of a 1-liner has been immense for me instead of repeating the code over and over. So in the framework/micro-architecture scheme, can I say that these are my internal in-house framework or are they part of a micro-architecture?
Trying to understand this topic better.
a framework is a library. it is the complement of component sets (or component libraries), which are also libraries. while component sets provide functionality (encapsulated in components), a framework provides architecture. so when using a component, you create the architecture, which embeds this component to use its functionality by making explicit calls through its interface. when using a framework, you actually provide the functionality, which is then called by the framework. this is called inversion of control, which basically leads to low coupling through dependency inversion.
Flex is both a framework as well as a component set. There is only little seperation between both in Flex, which is due to the fact that the Flex framework uses a hell lot of inheritance. Also, Flex provides only little framework features to the developer, but more to the Flex components themselves. That's why there is Cairngorm, PureMVC and many other frameworks on top of Flex.
From what you say, I'd call your library a component set. I know the word framework is very hip at the moment, but you shouldn't join the league of the many people totally misusing it.
Oh, and the term "micro-architecture" designates the internal architecture of a processor. I think framework actually is the word you were looking for.
I have been seeing some Flex Frameworks, but would like to ask to the programmers and Architects down here on which has suited best in your application.
Cairngorm
Pure MVC
Mate Framework
Custom One.
After using, in turn, all three of frameworks you listed, I can easily conclude that Mate is by far the superior framework. Of course, that's only my opinion and determining what makes a framework superior differs depending on your requirements.
To me, Mate's most appealing feature is how well it separates the different tiers of your application. After becoming familiar with it, I could never go back to using a framework that makes extensive use of global-state "Singletons" (Cairngorm, PureMVC).
However, Mate can probably be a bit difficult getting started with as the documentation is still a bit lacking and outdated, making it hard to know where to find the newest information. Some of the best practices and approaches that have been ironed out are to be found in the Mate forums, requiring some digging through posts. One of the most active users on that forum, Theo, has written a very good summary on the benefits of Mate in the following post:
Flex MVC Frameworks
PureMVC.... I like to have control and not relying on data binding... also since its been ported in different languages it has more value in my book than just a Flex only framework. Overall any MVC architecture is a plus in my book and it comes down to personal coding style/preference.
Cairngorm, and when I can't use Cairngorm (say, when using Flash CS3), I will simulate it (and it is really easy to duplicate conceptually). It is easy to set up, stupid simple, lightweight, and fast. If done correctly, it also forces a VERY clear separation of form and content. It fits in brilliantly with the native Flex classes and exploints data binding to the fullest. Of course, this might have something to do with the fact that it is the standard which Adobe explicitly endorses. Further, it is by far the most popular, which means if you need other people to be brought in and work on your projects, it will be far easier to find people who know Cairngorm than people who know the alternatives.
I find PureMVC incredibly bloated, non-ActionScript intuitive, and generally useless unless you work in a 99% Java company that does a very small amount of work with Flex and you want to have both use the same system.
I don't know anything about the rest.
From what I understand a framework reduces complexity in areas that are common, like a log-in system. I use ASP.NET MVC at work and have done some work in Zend Framework but do not get how a framework helps with client side development. The reason ASP.NET MVC is used at work is for Unit Testing - does a Flex framework help with this too?
Please let me know why I should or should not use a framework with Flex?
The short answer is: it depends on the framework. :) My thoughts below:
Flex is itself a framework, and you can write reasonable applications without the need for any additional framework. Flash has a built-in event model that allows for bubbling events, so you can dispatch an event in a deeply-nested user interface component and have a listener higher up in the hierarchy that handles the event. The event handler can delegate to your model, which retrieves data from the server, and Flex's binding support can ensure that your views are appropriately updated from the model. I think it's important to understand that Flex applications can and should be written more or less according to that approach, and that any additional framework should help facilitate that approach, rather than providing its own way of doing things that ends up coupling you to the framework.
That being said, an extra framework that helps facilitate this approach can absolutely provide value. I would recommend Mate or Swiz because I think they achieve this goal. They don't try to reinvent the wheel or replace parts of the Flash / Flex APIs; instead they complement them. The dependency injection features make it much easier to provide data to your views, but without coupling them to any framework. There are a number of utilities available to make it easier to work with remote services. They also have a utils to facilitate testing or even persisting data in shared objects.
I have also worked with Cairngorm in the past and I would not recommend it. CG is notorious for requiring you to create a ton of classes that adhere to CG-specific APIs and requiring you to use many of their Singleton implementations which make your app brittle and hard to test in isolation. It is based on a number of J2EE patterns which fell out of favor in the Java community at least 5 years ago.
I've read a little about PureMVC and while I can't speak to its invasive nature, I think that reinventing the event model (called "notifications") is silly and couples you to their framework. Sure, you can say it "insulates" you from the Flash event model in case it changes, but I'd say the odds of PureMVC changing their notification model is far more likely than Adobe changing the event model. :)
If you've ever tried building a slightly large application, or one at all complex, things can quickly get out of control. I don't know how many projects I bailed on when I was first starting out because I didn't know patterns, or how to make parts of the system communicate without being tied to each other, or dependent on each other.
So, basically a framework is a collection of patterns put together. Theoretically, if you learn to follow the "rules" of a (tried and true) framework, your app will not get out of control to the point where you find yourself fixing one bug and causing two. I've been there and it's not fun.
I also found that by learning to use a framework you initially don't have to know so much about the patterns behind what you're doing. But before long you'll get a good handle on the patterns used and you'll be able to apply them in new situations or find a better pattern. So it's a good learning tool as well.
I'm sure people will have arguments against using frameworks -- this is just my experience. But if you become familiar with a few, you will likely find that one might be suitable for one project but not another.
As far as Flex frameworks, I personally like PureMVC. In all honesty the only other one I've given a good amount of time to is Cairngorm. But I like PureMVC because it feels right to me, but also it's generally not dependent on so much on the built-in Actionscript classes. For example, it uses it's own notification system. So if the notifications change in Flex, they'll still work in your PureMVC app. Also, the creator Cliff is super helpful in his forums, and he's really passionate about it. And the documentation is great.
I recommend coming up with a super basic app, and building it without any frameworks, then again with a couple others. You don't have to finish the app, but just get a feel for what's behind the frameworks.
You may find value in using a framework if:
You work in a team environment and want to be sure everyone uses the same approach
You have a large, sophisticated app and want to communicate effectively between parts of the app
You want to be able to hire additional programmers and have them be productive quickly
You want to ensure your application is built with a proven architecture
You want to leverage the knowledge of design patterns and solutions that are known to work well
You want to simplify a complex application
Here's a great article on Flex frameworks.
Flex Framework Comparison
And, I agree with the conclusion...Mate is a great Flex Framework.
Another interesting framework not mentioned in this article is Spicefactory's Parsley.
I use PureMVC (which is an MVC-framework for Flex) for my larger applications. Like 99miles stated, it depends on the application size.
If you just have to make a (relatively) small tool/application, you can get it going with just Flex. But if you want to create a large, complex application a Framework might come in handy.
The main reason I use PureMVC in Flex is because of the Model-View-Controller architecture. This separates the presentation layer from the business layer and works a lot with events and notifications. This gives you a lot of control in creating reusable classes/controls in Flex in a relatively simple way.
As I said before, for a small tool/app/website I wouldn't recommend using a framework, because in that case it might be to time consuming and complex. But for the larger applications, frameworks are quite handy.
More information on the MVC architecture can be found here.
Hope this helps :)
I am a AS3 novice learning PureMVC and want to write code following best practices so that any other AS3 developer can pick up my code and easily understand what I did, I am tempted to do stuff as I would in JavaScript or Asp.Net/C#, but I have a feeling that might not be the best approach.
Thoughts? Links?
Using reverse domain folder structure is common from the Flex code I have seen. ie:
com/mydomain/myproject/view ... model, business, controller (this would make it easy for me to understand your code)
More: http://blog.tsclausing.com/post/11
ASDoc is a tool that creates very pretty HTML documentation from code comments automatically:
http://livedocs.adobe.com/flex/201/html/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Book_Parts&file=asdoc_127_1.html
You may be beyond this point but I have used Cairngorm (MVC) and it was well documented:
http://opensource.adobe.com/wiki/display/cairngorm/Cairngorm
Code Example
This is the Cairngorm store which is the standard Cairngorm example:
http://cairngormdocs.org/blog/?p=17
I found that reading through the docs helped me get a clear definition of each of the parts to PureMVC. On top of that I downloaded the source for the demos and added them in Flex Builder so I could look through them easily and see how they were constructed to get an idea of how I should construct my project.
One thing you have to remember is that you can do things any way you want, but to make using the framework worthwhile you should stick to the structure and way of doing things that it suggests. For example you could give your view a reference to the facade and have it get information from Proxies etc. But you should keep the view decoupled from the framework and just have it dispatch events and have a Mediator deal with the facade.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
I'm currently using and enjoying using the Flex MVC framework PureMVC. I have heard some good things about Cairngorm, which is supported by Adobe and has first-to-market momentum. And there is a new player called Mate, which has a good deal of buzz.
Has anyone tried two or three of these frameworks and formed an opinion?
Thanks!
Mate is my pick. The first and foremost reason is that it is completely unobtrusive. My application code has no dependencies on the framework, it is highly decoupled, reusable and testable.
One of the nicest features of Mate is the declarative configuration, essentially you wire up your application in using tags in what is called an event map -- basically a list of events that your application generates, and what actions to take when they occur. The event map gives a good overview of what your application does. Mate uses Flex' own event mechanism, it does not invent its own like most other frameworks. You can dispatch an event from anywhere in the view hierarchy and have it bubble up to the framework automatically, instead of having to have a direct line, like Cairngorms CairngormEventDispatcher or PureMVC's notification system.
Mate also uses a form of dependency injection (leveraging bindings) that makes it possible to connect your models to your views without either one knowing about the other. This is probably the most powerful feature of the framework.
In my view none of the other Flex application frameworks come anywhere near Mate. However, these are the contenders and why I consider them to be less useful:
PureMVC actively denies you many of the benefits of Flex (for example bindings and event bubbling) in order for the framework to be portable -- a doubious goal in my view. It is also over-engineered, and as invasive as they come. Every single part of your application depends on the framework. However, PureMVC isn't terrible, just not a very good fit for Flex. An alternative is FlexMVCS, an effort to make PureMVC more suitable for Flex (unfortunately there's no documentation yet, just source).
Cairngorm is a bundle of anti-patterns that lead to applications that are tightly coupled to global variables. Nuff said (but if you're interested, here are some more of my thoughts, and here too).
Swiz is a framework inspired by the Spring framework for Java and Cairngorm (trying to make up for the worst parts of the latter). It provides a dependency injection container and uses metadata to enable auto-wiring of dependencies. It is interesting, but a little bizzare in that goes to such lengths to avoid the global variables of Cairngorm by using dependency injection but then uses a global variable for central event dispatching.
Those are the ones I've tried or researched. There are a few others that I've heard about, but none that I think are widely used. Mate and Swiz were both presented at the recent 360|Flex conference, and there are videos available (the Mate folks have instructions on how to watch them)
Check out Robotlegs.
"It provides the glue that your application needs to easily function in a decoupled way. Through the use of automated metadata based dependency injection Robotlegs removes boilerplate code in an application. By promoting loose coupling and avoiding the use of Singletons and statics in the framework Robotlegs can help you write code that is highly testable."
I've seen these kinds of discussions many many times. They usually start with WHICH Flex framework do you use. Not many people ask the question WHY do you even need to use any framework on top of Flex framework.
I'm not in favor of using any MVC framework (Cairngorm, PureMVC) in Flex code. Mate is a better candidate. At least it's simple to understand and is non intrusive. I prefer using enhanced components à la carte. We've created and open sourced a bunch of them (see clear.swc in the Clear Toolkit at http://sourceforge.net/projects/cleartoolkit/.
The first chapter of our upcoming O'Reilly book "Enterprise Development with Flex" has a detailed comparison of several Flex frameworks: http://my.safaribooksonline.com/9780596801465 .
We are currently working on a MVCS implementation in the Spring ActionScript framework. It uses the full power of the Inversion of Control container so you have centralized dependency management and are able to swap things easily. It is not very prescriptive in how you do things but provides you with a very flexible infrastructure.
If you are new to Spring ActionScript and MVCS, I have an introductory post at my blog: http://www.herrodius.com/blog/158
I am using (and recommend) Swiz framework. It's not as complex and PureMVC, but it gets the job done. Moreover, it's a IoC container, and I like IoC.
I never used Mate, so I can't comment on that. But I do recommend against Cairngorm. Cairngorm is said to be open source, but it's really not supported well by the community. It's release cycle is also slow. I've been waiting FOREVER for Navigation Library to come out of beta.
Bear in mind that Cairngorm is THE adobe sponsored framework, and now hosted on opensource.adobe.com. Also note that it's by far the most prolific amongst developers at the moment.
If you know Cairngorm and are looking for a job, you won't go far wrong.
Cairngorm is easy to use and well documented:
http://www.cairngormdocs.org/
I recommend the Cairngorm Diagram Explorer and the classic article about Cairngorm.
I was new to Flex when I learned Cairngorm but found it useful and easy to learn with the above.
MATE is the way to go.A framework which does what a framework should do.
De-coupled architecture
Simple
Small foot print
Efficiency
I kinda have my doubts on these MVC frameworks (Mate, Cairgnorm, etc...) with the way they implement event maps and event controllers, it reminds me too much of wxWidgets and other GUI toolkits of that sort.
However, would be really nice is if Flex or one of these MVC frameworks uses the Signal/Slots paradigm that Qt offers.
I recommend to use MATE for developing greats and complicated projects,like other frameworks, Mate addresses the common architectural concerns in Flex such as event handling, data binding, and asynchronous processing, but the most important goal is that it's only tag-based so it's very easy to use it in our Flex Applications.
Yes Mate is the best framework for flex. I have used in one application which had several revisions both in terms of GUI and back-end data service. I only needed to change my event-map every time there was any change.
Mate also has MockService implementation which makes testing easy not a mate's advantage but nice to have one.
You should design you own MVC "framework" based on your own needs. If you know a bit of design patterns, Flex has a lot to offer natively.
Best thing of designing your own MVC is that it can be a light weighted or complex as you need.
My experience with frameworks is that you basically have to write twice as much code than you would without using a framework. The good thing about frameworks is, that it forces you to work in a consistent way, but if you can work in a consistent way by making use of Design Patterns, best practices and common sense, I would suggest to stay away from frameworks.
Its very difficult to come to a conclusion about which framework is better than others. Depending on the nature and complexity of project and team members expertise & preference one may be more suitable than other in a given situation
I have compiled a list of Flex Frameworks with there brief descriptions and pointers to more information about them in this URL.
http://practicalflex.blogspot.com/2011/08/list-of-adobe-flex-tools-frameworks.html
the url may be helpful for anyone looking for evaluating a Flex framework for his/her project.
After evaluating many most of the Flex frameworks I found the Swiz framework most simpler and easy to get started with for a new developer. Hence it ensures easy maintainability & extensiblity of your application.
I have worked on cairngorm and mate frameworks. I started with cairngorm framework. It is good to work but difficult to understand in the beginning. It handles event dispatching cleverly. You can dispatch events from classes itself and it will be taken care of by the framework wired command classes. There is single repository for storing the data, so easy to handle the data. It is a singleton class. Once you get a hold of the framework, work is easier.
Mate on other hand is tag based framework. It is an event driven framework, so all events are handled in the eventmap file. It does event listening, property injection, and many other things from this class itself. You can dispatch events from the classes by passing it the instance of framework event dispatcher. You don't have to use singleton class like cairngorm in this. You can bind property in a class to views using directly using property injection so no need to use any singleton class. In mate all the classes and view are free from framework code, so it is decoupled framework. It is easy to move components from one place to other.