Ele surgiu da necessidade de monitorar o uso de memória dos aplicativos, para determinar pontos onde o consumo crescia demasiadamente e verificar se o lixo estava sendo coletado corretamente.

Quando criado, ele se adiciona no stage e procura ficar no topo em relação aos outros objetos. Na sua interface exibe um gráfico de linhas que denotam três valores diferentes: o uso mínimo (em azul), o uso máximo (em vermelho) e o uso atual (em verde) de memória. Eles também são apresentados em números, além do frame rate que o aplicativo está rodando.

Para ilustrar seu funcionamento, foi criado um pequeno teste que tem como objetivo criar vários objetos e depois descartá-los, para gerar lixo na memória. O teste é um sistema de partículas, onde cada uma se move em coordenas polares (com velocidade e cor aleatória).

O componente precisa ser o mais leve possível, de forma a não gerar resíduos na memória e gastar pouco tempo da CPU. Como o gráfico é uma imagem vetorial, eu pretendia usar o método drawPath da classe Graphics para tornar o processo de desenho mais rápido. Entretanto, esse recurso está disponível apenas para o Flash Player 10, logo essa ideia foi abolida favorecendo as chamadas lineTo e moveTo.

Assim, o componente é compatível com o Flash Player 9 e qualquer versão superior.

Ele é distribuído sob a licença LGPL (Lesser GNU Public License).

Executar aplicativo de teste
Página do projeto no GitHub (com o código fonte)

A aplicação é bastante simples, vários clientes quando conectados ao servidor podem jogar uma bola de um browser para o outro. Quando a bola sai dos limites da tela de um cliente, ela é recebida pelo próximo e assim sucessivamente.

Usamos conceitos básicos da mecânica para modelar o movimento e controle da bolinha em duas dimensões (momento linear, atrito e colisão). No princípio havíamos planejado algo mais elaborado, mas por razões adversas acabamos finalizando em uma versão simples.

Como o projeto foi um experimento, o seu desenvolvimento foi um grande aprendizado (principalmente no meu caso, que não sou um programador Javascript).

Vídeo de exemplo:

O código fonte do projeto está disponível no GitHub.

Existe um pensamento muito errado sobre programar. Uma vez que nosso trabalho se dá mentalmente, há a tendência de nos verem como preguiçosos, e até de acreditarem que nosso trabalho é muito fácil.

Quem nunca ouviu comentários do tipo “queria um trabalho como o teu, coisa boa passar o dia na frente do pc”?

Mas aqui eu digo, meus caros, a maior parte das pessoas não aguentaria nossas atividades por uma semana sequer. Programar é mais do que brincar com o computador. Programar é pensar exaustivamente para criar sistemas cujo funcionamento é delimitado por (geralmente mal elaborados) briefings. É usar funcionalidades simples para criar comportamentos complexos, comportamentos estes que são apoiados, muitas vezes, em centenas (até milhares) de linhas de texto escrito em uma linguagem baseada em lógica e matemática.

E quem menos entende a função que desempenhamos são nossos chefes, que com uma grande frequência nos dão prazos ridiculamente curtos para criarmos sistemas absurdamente elaborados. Mas a culpa não é dos nossos chefes. De quem é, então?

O problema é a nossa sociedade. Estamos em uma época onde se espera que todos problemas sejam solucionados rapidamente. Essa época contemporânea informatizada dá a falsa impressão aos leigos que qualquer problema é simples de se resolver. Enganam-se eles.

Ser programador é quase como ser um maratonista mental. Não temos tempo de pensar na melhor solução. Precisamos apenas encontrar qualquer solução que não vá nos fazer perder tempo. Precisamos sempre nos superar, ser ágeis e, como se não fosse o bastante, precisamos estar sempre estudando, pois as evoluções nessa área se dão muito rapidamente.

Quantos de nós desenvolveu problemas de saúde por causa desta maldita profissão? Tendinite é o mais comum, mas vemos até complicações respiratórias por causa de horas de baixo de um condicionador de ar. Estamos sempre correndo pra satisfazer as expectativas dos clientes e chefes. O mercado é selvagem.

O que mais surpreende nisso tudo é como os programadores de modo geral são submissos e aceitam essa situação que lhes foi imposta. Acho que é inerente ao ser humano aceitar a situação, por pior que ela seja, se ele não conhece outras possibilidades. Mas existem outras possibilidades se lutarmos por elas.

Imagino o dia em que o programador será tratado com o devido respeito, pois a sociedade nos deve isso. O mundo do século 21 depende de nós para funcionar. Desde terminais de auto-atendimento de bancos até ligações telefônicas. Mas eles, que dependem de nós, nos tratam como nerds sem vida social que gostam de se submeter a essa situação patética.

Meu sonho, ainda que distante e improvável, é ver um levante dos programadores. É nos ver unidos lutando por melhores condições. É ver uma greve global de programadores que fará o mundo parar e nos observar. Nos entender como seres humanos.

Eu sei, esses ideais são quase inalcançáveis. Mas quem não sonha não vive.

Pense nisso.

And today I’m releasing version 0.3 with some nice improvements. The changes are described below:

Top level println function: previous versions of AS3Console needed a lot of writing to print text into console window. Since the component is a singleton, the call was:

Console.getInstance().println(text);

Now a top level function behaves as an alias of the call, making faster to write strings to console. The function name is cpln (Console Print LN):

cpln(text);

CodeEval plugin: an input plugin was added and it behaves similiar to Actinscript1 and Actionscript2 eval function. This plugin gets an input text from console, compiles it to AVM2 bytecode and execute it. To achieve this functionality the component uses AS3 Eval Library. Unfortunately, AS3Eval doesn’t seems to be updated for a long time.

To activate CodeEval plugin use the following code just after creating console singleton:

CodeEval.start();

And to evaluate any code from console input text field just type:

eval cpln("Running code from AS3Console! LOL");

AssetFactory class: a new class was created to manage console appearance. On previous versions, the layout was hardcoded and really difficult to change. This simple class have methods which you must override to change console visual. To set a new AssetFactory just do the following:

Console.getInstance().setAssetFactory(new AssetFactory());

FIREBUG_ECHO property: similiar to TRACE_ECHO, this new property allows console to redirect every output to firebug window. Usefull when developing a flash application to run within a web browser. To activate this functionality just set FIREBUG_ECHO property to true:

Console.FIREBUG_ECHO = true;

Where to download?

AS3Console project was moved from GoogleCode to GitHub: https://github.com/loteixeira/as3console

Or you can download the packages here:
Download AS3Console 0.3 source code
Download AS3Console 0.3 documentation
Download AS3Console 0.3 demo
Download AS3Console 0.3 pre-compiled library

This software is open source and is distributed under the terms of the GNU Lesser Public License.

Check Ulam Spiral article at Wikipedia

I created a version of Ulam Spiral using Actionscript3 with bitmaps. The algorithm iterates through every pixel and sets a color to it according to the correspondent number. Prime numbers are red, square numbers are green and regular numbers are black pixels.

Download Actionscript3 Ulam Spiral source code
Run Actionscript3 Ulam Spiral (requires Flash Player 9)

The behavior of the application is pretty much the same, only the viewPort attribute of Stage3D has changed and a open source header was added to all files of the source code.

You can download Flash Player 11 Beta here.

Download Molehill Heightmap Viewer 1.1 source code
Download Molehill Heightmap Viewer 1.1 binary package
Run Molehill Heightmap Viewer (require Flash Player 11)

An example of the simplest scenario for using this class:

var loadQueue:LoaderQueue = new LoadQueue();
loadQueue.addEventListener(LoadQueueEvent.LOAD_END, loadEnd);
loadQueue.setFileList(["file1.txt", "file2.jpg"], [LoadQueue.TEXT, LoadQueue.IMAGE]);
loadQueue.start();

It’s important to specify the file type in setFileList method, because after the object dispatches LOAD_END event you can retrieve the loaded objects already casted to correct type. However, you can use LoadQueue.UNDEFINED property to receive the raw data (a ByteArray in case of binary file or String for text file).

Whether you need to receive all events, here’s a list of them:

loadQueue.addEventListener(ErrorEvent.ERROR, error); // an error occurred when processing requests
loadQueue.addEventListener(IOErrorEvent.IO_ERROR, ioError); // a request has resulted in an IO error
loadQueue.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityError); // security problems - flash sandbox issues
loadQueue.addEventListener(LoadQueueEvent.LOAD_START, loadStart); // load queue process started (before load any file)
loadQueue.addEventListener(LoadQueueEvent.LOAD_END, loadEnd); // load queue process ended (after load all files)
loadQueue.addEventListener(LoadQueueEvent.FILE_START, fileStart); // load queue starts to load a file
loadQueue.addEventListener(LoadQueueEvent.FILE_END, fileEnd); // load queue has complete a file
loadQueue.addEventListener(LoadQueueEvent.FILE_PROGRESS, fileProgress); // load progress of a file

After the loading process, you can retrieve the objects using getObjects method:

var objects:Array = loadQueue.getObjects();

This software is open source and is distributed under the terms of the GNU Lesser Public License.

Download LoadQueue source code and example application

I had the idea to develop a Heightmap Viewer few years ago. Every time I worked on a game, or any 3D software using terrains, I always thought on a tool to easily visualize heightmaps (and even customize them). This simple project was postponed because I would rather to create a multiplataform application, but the technologies from that time were too complicated, too heavy and OS-dependant  (an option was C/C++ using any free 3D engine). The ideal scenario was a platform-free application without need to install anything.
Currently, thanks to Stage3D (Flash) and WebGL (Javascript), it’s possible to create such application to run on a web browser.

Molehill Heightmap Viewer was developed using Actionscript3 and Stage3D API, compiled via FlexSDK and uses MinimalComps library to manage the graphical user interface. It was created without any engine or framework, using only Adobe utils classes, such as AGALMiniAssembler and PerspectiveMatrix3D. The application can load images (heightmaps or textures) from your computer or from the web, moreover the main SWF file is able to receive parameters in order to customize the behavior and appearance of loaded terrain. You can gather more information within application’s help.

This software is open source and is distributed under the terms of the GNU Lesser Public License.

Note: to execute this program you need to install Flash Player Incubator (some kind of beta version). Click here to be redirected to the download page.

Click here to download the source code.
Click here to download the pre-compiled binary package.
Click here to run Heightmap Viewer application.

Suas principais caracteristicas são:

• o componente é um singleton, derivado da classe EventDispatcher;

• suporta entrada e saída de texto;

• teclas de atalho para esconder/exibir sua interface gráfica;

• facilidade de remove-lo em releases; e

• totalmente sem dependências.

Finalizado o projeto principal, notei que o componente de console ficou razoavelmente útil. Então decidi torná-lo opensource e investir um pouco do meu tempo na melhoria dele.
O projeto é distribuido sob a licença LGPL e está hospedado no google code. Lá é possível encontrar o código fonte, o SWC pré-compilado, a documentação e um aplicativo de exemplo.

Ir para a página do projeto
Executar o aplicativo de exemplo

Logo no começo dessa empreitada eu esperava uma diferença gritante de desempenho entre os códigos gerados. No entanto, de todos computadores que o aplicativo foi testado a maior diferença foi de oito frames por segundo a favor do Alchemy.

O teste consistiu na criação de um sistema de partículas (Particle System em inglês) para simular fogo. Dois renderizadores foram criados: um escrito em Actionscript3 e compilado na IDE do Flash e outro em C compilado com o Cygwin através do Alchemy. O trabalho de cada renderizador consiste em desenhar o sistema de particulas sobre um bitmap que será exibido na tela. Os algoritmos desenvolvidos em ambas linguagens são extremamente semelhantes, ficando as diferenças a cargo dos diferentes conceitos das linguagens.

O código fonte é distribuído sob a licença LGPL (Lesser GNU Public License).
Download ParticleSystem – código fonte (Actionscript3 e C)
Executar ParticleSystem (requer Flash Player 10)