Para os mais atentos foi lançada a compilação de todos estes tutoriais à um tempo atrás, basta procurarem no blog, que teve algum sucesso o que me levou a escrever uma segunda parte apenas em pdf que distribui inicialmente consoante uma doação, e que mais tarde também foi distribuída num pequeno “giveaway” e que agora finalmente será distribuída publicamente para o publico. Esta segunda parte do tutorial será dividida em vários post’s durante algumas semanas, e no final será colocado o pdf para download… se necessita urgentemente desta segunda parte (conta com 60 novas paginas) então entre em contacto comigo no twitter ou por email justificando essa necessidade que talvez sejam dos primeiros a receber esta segunda parte gratuitamente, embora haja alguns desses contactos que possam não ter resposta não desesperem… vai ser rápido para estar completamente publicado.

Este tutorial foca o Action Script 3 Orientado para o Flex, mas na sua base a estrutura é exactamente a mesma para o flash, por isso será com certeza útil também para os amantes do flash.

Nota: Não sendo um profissional, as técnicas adoptadas podem não ser as mais correctas, podendo mesmo existir alguns erros, mas bom… se detectarem algo “anormal” me informem.

Bom, vamos então à parte 12.

Não utilizem o sistema de comentários em baixo para tirar duvidas, elas não serão respondidas aqui! Usem antes o fórum do blog disponivel em: http://forum.msdevstudio.com

Continuando… Falaremos agora de (notem que os pontos podem nao estar seguidos, a versão final sofreu pequenas alterações):

5.3. Relacionamento entre classes.

Neste momento a nossa class passa a pertencer ao grupo de classes pessoais que podemos adicionar ao nosso projecto.
Um dos pontos muito úteis é o reaproveitamento do código para as mais variadas coisas, e de entre as quais podemos usar um relacionamento entre varias classes pessoais.

Um exemplo pode ser a definição de certas constantes numa class. Vamos supor que necessitamos de ter definidos tamanhos e um titulo para vários painéis feitos pela class em cima, poderemos efectuar 2 tipos de classes para este efeito, embora para este tipo de definições possamos usar uma class sem “inicializador” (apenas servirá para definir constantes / variáveis)
[coolcode lang="actionscript"]
package teste
{
public class def
{
public const PANEL_W:int = 400;
public const PANEL_H:int = 300;
public const PANEL_TITLE:String = “Painel personalizado”;
}
}
[/coolcode]
Esta class  não necessita de ser inicializada porque apenas apresenta parâmetros fixos da nossa aplicação e não têm um constructor.

Na nossa class em cima vamos colocar em prática o uso desta nossa class, editando a class teste.as e fazendo o seguinte.
No topo a seguir aos imports coloquem:
[coolcode lang="actionscript"]
import teste.def;
[/coolcode]
e na nossa função criado() substituimos a linha:
[coolcode lang="actionscript"]
_nomePessoal=”Teste Painel “+Math.floor(Math.random()*15);
[/coolcode]
por
[coolcode lang="actionscript"]
_nomePessoal=def.PANEL_TITLE+Math.floor(Math.random()*15);
[/coolcode]
Neste momento o titulo de cada painel criado será iniciado pela definição colocada na class def:
[coolcode lang="actionscript"]
public const PANEL_TITLE:String = “Painel personalizado”;
[/coolcode]
vamos também definir o tamanho fixo do nosso painel da class, trocando na função teste() o seguinte:
[coolcode lang="actionscript"]
//definimos o painel
this .width=270;
this .height=270;
[/coolcode]
por
[coolcode lang="actionscript"]
this .width=def.PANEL_W;
this .height=def.PANEL_H;

[/coolcode]

Desta forma, todos os paineis criados pela nossa class teste terão sempre as definições :
[coolcode lang="actionscript"]
public  const PANEL_W:int = 400;
public  const PANEL_H:int = 300;
public  const PANEL_TITLE:String = “Painel personalizado”;
[/coolcode]
Este tipo de definições são muito úteis quando há necessidade de ter sempre constantes na nossa aplicação, por exemplo num caso de uma aplicação que se liga a um banco de dados, podemos guardar o host e informações de login.. neste caso, apenas com um problema. Estas constantes apenas podem ser lidas, visto que são constantes e apenas podem ser alteradas pelo criador da aplicação e compilando de novo a aplicação.

Este trabalho poderia ser feito pela class seguinte:
[coolcode lang="actionscript"]
package  teste
{
public class definicoes
{
public const PANEL_W:int = 400;
public const PANEL_H:int = 300;
public const PANEL_TITLE:String = “Painel personalizado”;

public function definicoes()
{

//constructor

}

}
}
[/coolcode]
Mas neste caso teríamos algum código inválido, ou seja, o definicoes() ira ser inicializado em vão.. não temos necessidade de o ter no código (embora o possamos ter)

O action Script 3 é tão versátil que nos permite inclusive extender uma class já feita para trabalhar com outros exemplos, vejam o exemplo seguinte que estende a nossa class de definições.
[coolcode lang="actionscript"]
package  teste
{
public class fullDef extends def
{
public const PANEL_DATE:String = “20/09/2008″;

public function fullDef()
{

}

}
}
[/coolcode]
Este método cria uma nova class fullDef que estende a nossa class def, por palavras mais simples esta class usa as definições da class def em si própria, ou seja, herda (hereditária) as variáveis da class que está a ser estendida:
[coolcode lang="actionscript"]
public  const PANEL_W:int = 400;
public  const PANEL_H:int = 300;
public  const PANEL_TITLE:String = “Painel personalizado”;

[/coolcode]

e trata-as como se fossem suas, ou seja estas mesmas variáveis estarão disponíveis na class fullDef, basta testarem da seguinte forma:
[coolcode lang="actionscript"]
var  fid:fullDef = new fullDef;
[/coolcode]

e a partir deste momento as constantes da nossa class def de definições estarão também disponíveis nesta nossa class, juntamente com a constante PANEL_DATE que adicionei em cima, pela seguinte forma:
[coolcode lang="actionscript"]
fid.PANEL_DATE;
fid.PANEL_H;
fid.PANEL_TITLE;
fid.PANEL_DATE;
[/coolcode]
De notar que uma constante não pode ser alterada depois do nosso código ter sido compilado num ficheiro .swf.

Para esse efeito usamos apenas private var, e se o formos fazer usando a  nossa class de definições e a class fullDef deveremos usar o método [Bindable] já explicado anteriormente e que vai permitir que todas as classes que utilizem a nossa class def sejam actualizados com novos valores.

Esta extensão funciona com variáveis, constantes, e funções quer das nossas classes pessoais ou das classes do Flex / Flash.

Bom, por agora é tudo… até uma próxima…

Sugestões? criticas? e porque não elogios? deixe um comentário…

Duvidas? Use o fórum.

Começando…

Com o Flash player 10 e o Flash CS4 disponivel, bem como o aproximar do lançamento do Flex 4 e thermo (esperemos) o Action Script 3 está a ficar na moda, e cada vez vejo mais pessoas à procura de informações sobre como se iniciarem no AS3.

A grande base para entender o AS3 é a compreensão de linguagem orientada a objectos que utiliza uma estrutura de código optimizada baseada em funções que são executadas por “pedido” a esse código e pela devida hierarquia e que asseguram o melhor desempenho da aplicação / animação. A grande vantagem do AS3 é permitir separar muito do código em pequenos arquivos que ao serem compilados ficam disponiveis na aplicação como parte conjunta.

Apesar de inevitavelmente trazer muitas vantagens, também pode ser um pouco complicado entender o AS3, mas vamos por passos;

A OOP, ou POO (Programação Orientada a Objectos), traz consigo uma robusta forma de desenvolver o código da nossa aplicação, que comporta muitos melhoramentos como:

• Estrutura de código, muito organizado e de facil compreensão.
• Reutilização do código, o que permite além de reduzir os custos de programação acelera em muito o desenvolvimento de aplicações devido à extensibilidade do código.
• A robustez e velocidade do código, que permite uma grande performance, com muito poucos erros que podem facilmente serem interceptados.
• Grande vantagem de migrações de outras linguagens principalmente o Java que comporta muitas semelhanças devido à sua já utilização de OOP.

A programação orientada a objectos basea-se na abstração do resto do código, e concentração apenas no “pedaço” de código/class que estamos a fazer, este peçado de código é considerado um objecto, que como qualquer elemento fisico tem caracteristicas, definições e propriedades… o mesmo se passa com estes objectos no AS3, vejam um exemplo:

Vida Real; Carro:

Caracteristicas: marca, modelo, ano

Funções: anda, trava, acelera, rodaVolante, acendeLuz, apagaLuz

Passando isto para uma class em AS3:

Caracteristicas/Variaveis: carro.marca , carro.modelo, carro.ano

Funções: carro.anda(); carro.trava(), carro.acelera(), carro.rodaVolante(), carro.acendeLuz(), carro.apagaLuz()

Isto para quem leu os meus tutoriais de AS3 já não é estranho, embora agora vá abordar o assunto de uma maneira diferente, explicando um pouco mais as classes.

Quando falamos de classes, temos que ter em especial atenção alguns pontos, principalmente porque são as bases da linguagem orientada a objectos, termos já presentes em muitas linguagens de programação como java ou php.

Dum modo geral, ao programar AS3 devemos ter em conta:

• Definição / escrita de classes
• Criação de Propriedades, métodos e definições de acesso e conteudo
• Controlo de acesso às classes, propriedades, métodos e definições / variaveis
• Criação de popriedades e métodos estáticos
• Definição e utilização de interfaces
• Utilização de métodos hereditários bem como a re-escrita de elementos das classes

Resumindo ao básico, uma classe engloba todas as propriedades de um objecto (podendo o objecto ser a sua propria class) bem como as suas definições e comportamentos. As classes no AS3 são compostas num arquivo de extensão .as e são consideradas como dados / objectos e podem ser declaradas como tal como se fossemos usar um outro tipo de objectos.

Uma class pode fazer parte de um “pacote/grupo” chamado “package” que pretende com que o código seja mais facilmente organizado para o programador e especialmente util na programação em grupo.

Vejam um exemplo, temos um carro e uma moto, como são ambos veiculos, podemos engloba-los no mesmo pacote, mas depois temos algumas diferenças, um têm 4 rodas, volante, 5 lugares e por outro lado temos a mota com 2 rodas, 2 lugares, guiador… nestas diferenças, para organizarmos ainda mais o código dentro do package “veiculos” podemos separar por:

Veiculos 2 Rodas

Veiculos 4 Rodas

Sendo que o nosso package estará distribuido como:

Veiculos->2 Rodas->Moto

Veiculos->4 Rodas->Carro

Se tivermos mais um bicicleta, fariamos:

Veiculos->2 Rodas->Bicicleta

Sendo que os nossos packages seriam: veiculos.duasRodas e veiculos.quatroRodas e as nossas classes Moto.as, Carro.as e Bicicleta.as.

Para criação dos packages destas classes, usariamos:

package veiculos.duasRodas {

}

e

package veiculos.quartoRodas {

}

Sendo que obrigatóriamente o  veiculos.quatroRodas representa a estrutura de pastas a partir da nossa pasta Source, raiz do projecto, vejam o exemplo do projecto em Flex da imagem ao lado, como podem ver, a pasta src é a pasta source do meu projecto, e é a partir desta que é feita a estrutura de pastas para definir o nosso package.

De seguida vou criar as pastas src/veiculos/duasRodas e src/veiculos/quartoRodas que vão organizar e identificar claramente as minhas classes. Pode ver também já os ficheiros (classes) Moto.as, Bicicleta.as e Carro.as devidamente criados e colocados nas suas devidas pastas. Assim se forma a estrutura do nosso package e suas devidas classes.

Esta é obrigatóriamente a estrutura de packages em AS3, sendo que uma class não têm obrigatóriamente de ser incluida num package, mas em projectos de media/grande dimensão é altamente aconselhavel a seguir este tipo de organização. O nome das classes devem sempre ser iniciados por letra maiuscula.

Vejamos o exemplo da class Moto:

package veiculos.duasRodas
{
public class Moto
{
public function Moto()
{
}
}
}

Iniciamos com o package, definimos a nossa class como public para que possa ser instanciada (para que possa ser atribuida e utilizada como uma variavel) e definimos a função principal da nossa class como public também.

Esta é a estrutura base, sendo que podem ser usados diferentes tipos de declarações para a nossa class e funções, tais como:

• public – Declara a visibilidade maxima, publica, que é visivel por todos os elementos da nossa applicação.
• internal – Visivel unicamente dentro do nosso package, apenas possivel de utilização interna.
• final – Class final, impossivel de ser extendida por outra class.
• dynamic – Class dinamica, possivel de ser alterada com dados durante a execução da aplicação adicionando propriedades à mesma.

As declarações final e dynamica devem ser usadas como sub elementos na declaração da class, como:

• public final class Moto
• internal dynamic class Moto
• public dynamic class Moto

Depois de uma class elaborada, ela não fica automaticamente disponivel na nossa aplicação, quando a desejar-mos usar devemos indicar à aplicação que ela deve ser incluida, para isso usamos o import, indicando o seu caminho a partir da pasta raiz do projecto:

import veiculos.duasRodas.Moto;

E deve de seguida ser instanciada, usando a palavra new:

private var cbr:Moto = new Moto();

A partir deste momento a nossa class encontra-se instanciada na variavel cbr e pode ser usada na nossa aplicação.

As nossas classes podem conter atributos, ou propriedades que podem igualmente ser indicadas como variavies, podendo seguir o seguinte código:

package veiculos.duasRodas
{
public class Moto
{
public var modelo:String;
public var marca:String;
public var cor:uint;

private var velocidadeActual:uint=0;

public function Moto()
{
}
}
}

onde foram declaradas as variaveis/propriedades modelo, marca, cor onde estão acessiveis a toda a aplicação, desde que a class tenha sido instanciada, estas declarações podem ser de alguns tipos:

• public – Passivel de ser acedida e definda ao longo de toda a aplicação e instancias
• private – Apenas para uso da nossa class, não acessivel fora da mesma nem em sub-classes
• protected – Acessivel para uso da nossa class, mas também nas sub-classes
• static – Acessivel para uso na class mas também na sua instancia.

Depois da definição da class e suas propriedades podemos definir métodos, ou acções executaveis da nossa class, conhecidos como métodos, podem ser definidos como funções:

public function acelera(velInc:uint):void {
velocidadeActual+=velInc;
}

onde definimos a função como public, que recebe o incremento de velocidade como argumento e que o incrementa na velocidadeActual. Estes métodos podem ser declarados como:

• public – Visivel em todo o código na instancia da class.
• private – Visivel internamente na class mas não nas sub-classes.
• protected – Visivel na class e sub-classes.
• static – Apenas visivel na class, mas não nas instancias da mesma.

Podem não ter reparado, mas na class que dei exemplo existe uma função com o mesmo nome da class:

package veiculos.duasRodas
{
public dynamic class Moto
{
public var modelo:String;
public var marca:String;
public var cor:uint;
private var velocidadeActual:uint=0;

public function Moto()
{
}

public function acelera(velInc:uint):void {
velocidadeActual+=velInc;
}
}
}

Esta função é chamada de constructor, e todo o conteudo desta função é imediatamente executado assim que a class é instanciada usando a palavra new, como em cima foi explicado. Este método é obrigatóriamente publico (public) e não pode ser declarada com qualquer um dos outros “controladores de acesso” como private, internal ou protected.

O constructor da class pode ser usado para definir valores / propriedades da mesma class assim que esta é instanciada, por exemplo:

public function Moto(modeloM:String, marcaM:String)
{
modelo=modeloM;
marca=marcaM;
}

onde os argumentos modeloM e marcaM devem ser indicados na instanciação:

var cbr:Moto=new Moto(“CBR”,”Honda”);

Estes argumentos podem ser opcionais, mas devemos para isso indicar um valor por defeito para eles:

public function Moto(modeloM:String=”R200″, marcaM:String=”Suzuki”)
{
modelo=modeloM;
marca=marcaM;
}

onde podemos na sua instanciação declarar ou não esses argumentos:

var cbr:Moto=new Moto(“CBR”,”Honda”);

var cbr:Moto=new Moto(“CBR”);

var cbr:Moto=new Moto();

Onde, na ausencia de atribuição de algum dos elementos (modeloM,marcaM) a função assumirá os valores pode defeito (modeloM=”R200″ e marcaM=”Suzuki”).

Nas classes existem alguns pontos que podem ser muito importantes na sua estrutura, falo de acessores, tipicamente conhecidos como getter’s e setter’s que permitem definir internamente uma variavel não alteravel na sua instancia, tais como variaveis private.

Estes get’s e set’s permitem definir/aceder a uma variavel privada sem que tenhamos que definir uma função public para aceder aos mesmos. As variaveis sujeitas a este tipo de acessores devem ser iniciadas pelo caracter _ como mostra em baixo:

private var _velocidadeMax:uint;
private var _rotacaoMax:uint;

Para definirmos os acessores, tratamo-los como funções mas com algumas caracteristicas, no caso dos get (busca):

public function get velocidadeMax():uint {
return _velocidadeMax;
}

onde definimos como public, usando a palavra get nomeDaVariavel e devolvendo o mesmo tipo de dados da mesma variavel. Devolvemos com o retun a variavel.

No caso dos set, para definir o valor de uma variavel, usamos:

public function set velocidadeMax(vel:uint):void {
_velocidadeMax=vel;
}

De notar que em ambos os casos a variavel na declaração da função é usada sem o caracter _.

Ao usarmos estes getter’s e setter’s (podemos usar os que quisermos e podemos apenas usar um deles dependendo se queremos apenas definir ou ler os dados dessa variavel) estamos a indicar que na instancia da class a variavel private pode ser lida e alterada:

private var cbr:Moto = new Moto(“CBR”,”Honda”);

cbr.velocidadeMax=240; //usando o set

var vel:uint = cbr.velocidadeMax; //usando o get

Outra forma de alterar estas variavei, poderia ser utilizando métodos/funções, mas desta forma na instancia serão disponibilizadas muito mais funções e que em class maiores pode confundir a baralhar a programação, vejam:

public function buscaVelocidadeMax():uint {
return _velocidadeMax;
}

public function  defineVelocidadeMax(vel:uint):void {
_velocidadeMax=vel;
}

mas desta feita teriamos que usar:

private var cbr:Moto = new Moto(“CBR”,”Honda”);

cbr.defineVelocidadeMax(240);

var vel:uint = cbr.buscaVelocidadeMax();

Podemos perceber algora alguns exemplos, como o que se segue que serve para enumeração, ou seja, permite definir um tipo de dados com um determinado valor, muito util para certas constantes de utilização e comparaçao na nossa aplicação, vejam:

public final class HondaCBR {

public static const cilindros:uint=2;
public static const marca:String=”Honda”;
public static const modelo:String=”CBR”;

public static const serie:String=”CBR-RX001-2006″;
public static const velMax:uint=280;
}

Esta class apenas serve para defiir dados, como se trata de um função public final pode ser acedida por toda a aplicação, mas não pode ser extendida/alterada bem como as suas variavies constantes e inalteraveis durante a execução.

Vejam na nossa class original, poderiamos colocar esta class HondaCBR.as no nosso source e colocar:

import HondaCBR;

public function Moto(modeloM:String=”R200″, marcaM:String=”Suzuki”)
{
if(modeloM=HondaCBR.modelo && marcaM=HondaCBR.marca) {
_velocidadeMax=HondaCBR.velMax;
modelo=HondaCBR.modelo;
marca=HondaCBR.marca;
//podendo aqui ter acesso a toda a class de definições:
//HondaCBR.serie
//HondaCBR.cilindros
}
else
{
modelo=modeloM;
marca=marcaM;
}
}

Assim fariamos com que identificasse-mos rapidamente as caracteristicas da nossa moto, sendo que é um exemplo de entre muitos que podem simplificar muito as coisas em as3.

Existem alguns pontos também muito uteis, como interfaces ou re-escrita de métodos, embora já exija um bom conhecimento da programação AS3 e como o post já está bem grande, fica para uma próxima oportunidade.

Espero que as coisas fiquem mais simples agora e que pelo menos o AS3 seja desmistificado.

Um abraço.

Vejamos…

Flex, é o nome em si de uma nova tecnologia baseada no flash. O flex não passa de uma framework para a plataforma flash, que implementa o flash com um aspecto visual muito mais elaborado transformando-o com um conteudo rico (RIA – Rich Internet Aplication) muito por causa da sua capacidade de inter-agir com enumeras linguagens de programação como php, asp, .net ou java e com as mais completas bases de dados e API’s. Ou seja, quase tudo o que é feito em flex é possivel de fazer no flash, tendo como grande diferença no flash teriamos que criar todos os passos, e no flex, como é uma framework já possiu muitos componentes prontos a usar. Iniciado pela Macromedia em 2004 não tendo sido muito popular entre desenvolvedores, Mais tarde comprado pela Adobe (um dos primeiros softwares que a adobe comprou à macromedia, primeiro de todos) e lançado no mercado com o nome Adobe Flex, nome que toda a gente conhece.

Air, (Adobe Integrated Runtime) uma aplicação  que permite conteudo flash / aplicações desenvolvido em Flex serem executadas no Desktop / Ambiente de trabalho sem necessidade de instalações elaboradas. Aumenta a possibilidade de extender o flash ao desktop permitindo ao flex ser considerado na hora de desenvolver uma aplicação para desktop que tenha grande necessidade de suporte online, com uma facilidade e capacidades extremas pode mesmo ser usado “apenas” para uma simples aplicação como um leitor de video ou editor de texto.

Flex SDK, este é dos termos mais falados e não é nada mais que o “core”/coração do flex, são as tais funções da framework prontas a usar. Chamado de Kit de desenvolvimento de software (Software Development Kit) permite que posssamos usar todas as funções / elementos do flex nas nossas necessidades. (O SDK é gratuito e possui um compilador para compilar o nosso codigo e transforma-lo num .swf)

Flex Builder. Aqui podem existir muitas confusões… para desenvolver Flex não precisa do Flex Builder. Pode até usar o notepad, passo a explicar. O Flex Builder é um aplicativo que apresenta uma estrutura gráfica de apoio para o desenvolvimento de aplicações baseadas no nosso SDK (Chamadad de IDE – Integrated Development Environment), ou seja, é uma interface para o nosso SDK. O flex builder (software / ide ) foi baseado no Eclipse, um popular programa para programação das mais diversas linguagens. Como este é eclipse é versavel ao ponto de ser polivalente na interpretação de varias linguagens, a adobe decide basear o seu Flex Builder neste mesmo software. O Flex Builder é Pago (excepto instituições de ensino e estudantes).

Eclipse. O programa que falei em cima, como disse é polivalente ao ponto de interpretar muitas das linguagens comuns com recurso a algumas plugins, inclusive existe uma plugin “flex builder” para o eclipse, que o transforma num autentico Flex Builder, mas esta extensão é paga. O eclipse (gratuito) é muito popular entre empresas / desenvolvedores / programadores por ter um grande suporte, ser muito completo e por suportar enumeras linguagens de programação. É mesmo usado por grandes empresas e grandes projectos como o Zend Studio, Aptana, Borland ou até IBM (principal “investidora” do projecto).

Action Script é a base de tudo o que estamos a falar em cima, ou seja, apesar de o Flex usar uma variação do xml (MXML) para definir mais rapidamente alguns componentes da aplicação, na hora de compilar tudo vira Action Script 3. Esta linguagem é apontada como infinitamente extensivel o que nos permite conseguir fazer quase tudo com ela e principalmente obter uma grande variedade de componetes / extensões já feitas na comunidade e o mais interessante é que sendo uma linguagem orientada a objecto é de rápido desenvolvimento e para quem já trabalhou com o AS3 no flash é praticamente a mesma coisa. A grande dificuldade pode ser a passagem do AS2 para o AS3, mas posso indicar, não é assim tão dificil como parece e com pouco tempo vão passar a esquecer o AS2.

Assim que começei a desenvolver em AS3, esqueci completamente o AS2, mesmo no flash 8 onde ainda desenvolvia alguns sites em AS2 e que agora passei a fazer com o AS3. Muito mais rápido, pratico e eficaz.

Bem, para iniciantes em flex (e que não conheçam o Eclipse) o flex builder ainda é sem duvida a rampa de lançamento para iniciantes, pelo simples motivo de ter uma interface apenas orientada para o Flex e Air e ser de facil interpretação. O suporte do flex é enorme e têm por detrás a gigante adobe, pelo que podem contar com a muito boa qualidade de tutoriais e artigos (inglês) e como a comunidade de utilizadores / desenvolvedores está cada vez mais a aumentar, já se pode encontrar muito boa informação em Potuguês, incluido aqui no blog como o “Adobe Flex a partir do Zero” disponivel para download aqui e a introdução ao action script 3 “trace (‘Action Script 3′)” disponivel para download aqui. Se percorrerem este blog encontrarão com certeza muita informação, bem como links para mais alguns blogs com muito boa informação e tutoriais.

Mais informações:

Ria – Rich Internet Aplications na wikipedia – Veja

Adobe Flex – Site oficial – Veja

Adobe Open Source – Flex SDK – Veja

Adobe Air – Veja

Eclipse – Site Oficial – Veja

Flex.org – Site de suporte e showcase – Veja

Bom, espero que tenham ficado esclarecidos e agora saibam por onde começar..

Abraço.