Key Concepts in Gugga Flash Framework?

This is the first of a series of articles that will introduce the key concepts in the Gugga Flash Framework. The idea behind those articles is trivial to easy the process of Introducing developers to the framework. Before we dive in the key concepts we owe you a little more insite and something as a definition of what the framework is.
The Gugga Flash Framework is a library of application building blocks designed to assist developers with common development challenges.

Application blocks are set of classes that can be asociated to movie clips and used "as is", extended, or modified by developers to use in Rich Internet Applications (RIA) projects. They are designed to encapsulate the best practices for Flash and enterprice applications, help address the common problems that developers face from one project to the next, and also addresses scenarios not directly supported by the underlying class libraries supplied by Macromedia.

The GuggaFF focus in Rich Internet Applications determine that main concepts in the framework are those of the Section, Application and Task and Sequence. To create an application using the GuggaFF you mush have at least :

Section

The Section is the main application building block. If nothing else a single section will exist and this will be the Application. The name Section was chosen because the abstraction Section is a common knowledge for everyone who was ever involved in creating a web site. The Section abstraction also implies:

* one can navigate from and to a Section
* that it is a container assuming responsibility for a certain level of encapsulated functionality or information.

From a development perspective, in GuggaFF, the Section is a class. This class or its successor must be assigned to a Movie clip in a FLA file to allow its participation in an Application.

From a Designer perspective the Contents of the movie clip associated with the Section class can be edited using Macromedia Flash editor to add graphic symbols or other components.

This architectural approach follows our firm belief that we have to allow for separation of design from development work.

Section Controller

Besides Section we have one more very important player and this is the SectionController. SectionController is a kind of Section that contains other sections. If a Section must contain other Sections then it have to become a SectionController?. It acts like an Application for its own contained sections. Actualy the Application it self is an extension of a SectionController. This approach allows for unlimited level of nesting of sections without sacrifising flexibibility and ease of use.

Application

In GuggaFF the Application follows the MVC pattern, and acts as a “controller” that assumes responsibility to respond to navigation events, register and manage its contained sections. The Application responsibilities are not limited to control the Sections but are extended to :

* configure the entire application,
* preload globally used resources
* prepare data connectors
* other system wide tasks.

The Application is also associated with a Movie Clip

Task

Task represents small piece of work that has to be executed, or a function to be performed in order to constitute a complete unit of action. Tasks can be linked together in order to achieve desired result.

Code execution in Flash is always synchronous. All code that belongs to a frame must be executed before player moves to another frame. At the same time, many critical aspects in application development have an asynchronous nature. This includes but is not limited to:

* loading of external resources
* access to data and it’s processing
* waiting for user interaction
* initialization of components
* and so on.

Some of these actions cannot not even start before the playhead has moved to the next /sometimes virtual/ frame. This is real reason behind introducing the concept of the Task, to handle such situations.

Task are building blocks that can be either used alone or included into the Sequences. They :

* defines its own start and completion
* can either have synchronous or asynchronous nature
* can be externally manageable - their start can be invoked by someone when certain conditions are met.

Sequence

Sequences are used to organize task execution and synchronization. They are a representation of a workflow that must be executed in order to complete a complex process. Sequences can be linear or graph.

Linear sequences are intended to be sequential and to start next task, only when the previous one have completed. They are very easy to construct and can handle a web of situations.

In more complex situations a graph like Sequence /represented by class TaskManager? / can be used. In such cases the task execution time can depend on the completion of more than one Predecessor Task, or even External Preconditions. Task completion itself can trigger execution of more than one task. Multiple starting tasks and complex “complete” status determination are also possible to implement.

Sequences are also considered Tasks. You can include one sequence into another just like adding any other atomic task. Armed with that flexibility there are no restrictions to what you can acheive.

Sections and Application use sequences to perform their duties. For example a Section is intended to have 4 different sequences

* Initialization – executed only once and it prepares a section for work
* Activation – executed every time a section is nominated to be opened . This sequence is executed concurrently with the Closing Sequence of the Section being closed. It starts its execution when the Closing Sequence of the previously opened Section is started. This Sequence is intended to load external resources or reorganize the Section content
* Open - Opening Sequence is intended to reveal the currently selected Section. It starts its execution when Closing Sequence of previous section is completed.
* Close – executed when section is closed

The next set of articles will dive into greater detail as to how those key aspects interact or work