The most important thing when rewriting the old code is to decide which framework chose Yes framework or maybe only some utility classes ex smartypants ioc is better . I will say go with IOC 100% to separate your view from the logic part. You can loose some time when you’ve got some not organized code, or you are using the oldie framework but it will benefit in the future.

First Separate your business logic.

Badly written project have some business logic mixed up with the view logic. Services with specific calculations. When you will try to rewrite your application try to group your business methods in one part and the view logic in the other part. It’s easy in the Robotlegs Mediator so you can see what methods have it’s view.someFancyComponent reference and what have not. Put the minimum in the view components logic and separate other things to some Helper classes that you can refactor later. If  your project is quite big and getting larger you will see you have some helpers that methods are the same but maybe some little part is different. Try to use it as params. Once you clear your view logic out from business logic  you can separate the business itself to services logic and equations logic. Do equations in separate classes call it some strategy. ex. MyBudgetImportantStrategy if you are using DI you can insert it and decouple with interface and you can use unit tests in the future. The equations logic merely changes when it’s done right.  And you are ready for webworkers dude. You can then put your all equations to the worker. The update will be 1-2days not 1-2weeks, months when you wrote your code wrong and keep doing it.

Second be elastic with gui.

Well the gui part is the most important thing in the flex. It have changes. Well it is changing all the time. Maybe you remember some css issues when migrating from flex 2 to flex 3 and you will remember rewrite to the flex 4 and then you will remember if your boss told you compile it to mobile. The simple part is IOC. When you have IOC framework with your business logic highly separated from the gui. The gui logic is the bottleneck. If you screw this up and you need to refresh the look of your big enterprise application you are in hell now. You need to keep your mediators smart and simple, decouple the state and change layout logic from the interaction logic. The layout logic it the shit when you need to reorganize your components view the all the old layout is often the shit see the flex 3 and flex 4 states, flex 3 and flex 4 css. But the button clicks as it clicks it is the main functionality for it, combobox often is only combobox and list is a list. But it may be in the different state of your layout now. When you put your view components first think what is your functionality for this control. And try to put the functionality components separate from your layout component’s don’t mix them up or they will mix you up when refreshing the look.

Third

Think, read and ask, there are many people out there that have the same problems and there are many authorities in the world of flash/flex that write some good shit about every problem you have. But don’t chose the first solution of your problem the person who wrote it 3 years ago is not the same programmer now, maybe someone did it better so you can use it . Try to read more, yes it’s time consuming but when you rewriting you don’t want to rewrite it again and again. Maybe sometimes it’s better to mix some solutions up to build something better.  Use event’s as much as you can you can. Man if you have some performance problems why then not use signals or do some own simple notifications where you send often. The event’s are for you to keep your life easier not to kill you. Do the commands. The command is the shit cause it only have one functionality. You can separate it and use it in your logic.

Prototype only when your time is very limited but try to separate the 4 logical parts

- layout, - interaction,- services, - equations

cause  flashplayer is crossplatform only from the basis and you interact with phones, tablets other then on desktop or even game console. Your layout and functionality may be different for other screens and equations could be moved to the server when low performance. And on there is still more freedom on the desktop.

Happy codding ;)

Well if you have something like 1-10 modules you can keep everything in the same project I think. But what if your plan is to have 20-30 modules ? And by the way you have external people working on your project you not really want to share all your code. How to keep things consistent.  I’ll share my concept with you cause it’s simple. LIBRARIES, yes each module should have separate project library so you won’t use one module  codebase in another module codebase what’s modular application essential.  Next you need at least one common module for your framework classes that are shared across all modules. Let’s say it will be the Components, validators, renderers and some other visual related stuff I will name it CORE. I also managed to separate communication module that sends and receives the data from the services. And for this point I wanted to have all my communication classes in another module - let’s say the API. So you can use the API and give the api and the CORE to the external developer and he will do some shit for you. And you give him only SWC with some documentation not the all codebase.

Some conclusions:

- Unless you are moving something to the  CORE library or API library your project build time will be something like 1-2 seconds. That’s something. You are not frustrating while flashbuilder is building your project or freezes sometimes without memory.

- You don’t have to worry that you used some classes across modules and you don’t know what dependences are - you have it all in CORE. Your modules should be equal in size, and the size won’t be 10-40kB it will be all the classes you have in the library so 100-200kB so you will save some time while loading big application and showing it to client.

- If you managed to separate your SERVICE to the external module and that’s with all flash domain policy really hard shit, if you use some remote classes that you send or receive it’s really messy but then you can use it in some third party related project’s.

-You can then give the API and CORE  and see what other people will build with it.

In my workplace we are pushing some data to the clients, and more websites are pushing realtime data so it made me think. How hard it’s to write simple http push server for actionscript using python ?

Well it seems not so hard cause we got great library for it twisted. So let’s get started on server side:

We will be using twisted web server and Site object,JSON to send data, simplejson library to convert our objects to JSON

So we start by creating simple class Test with GET and POST handlers and in get we add server.NOT_DONE_YET to never stop sending GET request once connected. In __init__ method we declare array for users and array for messages to pass. Next we add LoopingCall task to throtle messages for our clients every 250ms, and define method __print_time that we will be using to create messages. Well __print_time is simple method that we pass time and messages when there are any in our messages array.
We simply loop in our users array and add aditional message to send.

Things to improve:
1. detect when user disconnect
2. add user id when connected
3. replace json with amf protocol

from twisted.internet import reactor, task
from twisted.web.server import Site
from twisted.web import server
from twisted.web.resource import Resource
 
import simplejson as json
import time
 
class Test(Resource):
    isLeaf = True
    def __init__(self):
        self.json_encoder = json.JSONEncoder()
        self.users=[]
        self.messages = []
        loopingCall = task.LoopingCall(self.__print_time)
        loopingCall.start(.25, False)
        Resource.__init__(self)
 
    def render_GET(self, request):
        request.write(self.json_encoder.encode({"time":time.ctime(), "type":"CONNECT"}))
        print "client connected"
        self.users.append(request)
        print "number clients:", len(self.users);
        return server.NOT_DONE_YET
 
    def render_POST(self, request):
        if request.args["msg"]:
            self.messages.append(request.args);
        print request.args
 
    def __print_time(self):
        sendMSG = None
        while len(self.messages) > 0:
            sendMSG=self.messages.pop();
        # keep alive connection
        for p in self.users:
            p.write(self.json_encoder.encode({"time":time.time(), "msg":[sendMSG]}))
 
print "server start"
resource = Test()
factory = Site(resource)
reactor.listenTCP(8081, factory)
reactor.run()
print "server stop"

Next what about client, some time ago I started simple library for my inhouse projects.
I created simple HTTPConnection class where I use URLStream for handling connection and some self created Observer for listening events instead of eventDispatcher.
Well I will not describe my classes here but only show the main class for the server class in python.
The main method is init where we create gui, HTTPConnection named consumer and some logger. We add event for progress where we simply try to parse json using as3corelib and if we have some messages we try to display it in our gui. when we press ENTER in our upper TextField we are simply sending post to the same url.

Things to improve:
1. detect when disconnected and try to reconnect
2. parse messages only when we need

package
{
	import clazz.GUI;
 
	import com.adobe.serialization.json.JSON;
 
	import flash.display.Sprite;
	import flash.events.DataEvent;
	import flash.events.Event;
	import flash.events.ProgressEvent;
	import flash.net.URLRequest;
	import flash.net.URLRequestMethod;
	import flash.utils.ByteArray;
 
	import pl.vane.framework.errors.Throws;
	import pl.vane.framework.logging.ILog;
	import pl.vane.framework.logging.Log;
	import pl.vane.framework.net.HTTPConnection;
	import pl.vane.framework.net.IConnection;
 
	public class Main extends Sprite
	{
		public function Main()
		{
			if(!stage)
				addEventListener(Event.ADDED_TO_STAGE, init);
			else
				init();
		}
 
		private var _gui:GUI;
 
		private var _consumer:IConnection;
 
		private var _log:ILog;
 
		protected function init(event:Event = null):void
		{
			_gui = new GUI;
			_gui.addEventListener(DataEvent.DATA, dataSendHandler);
			addChild(_gui);
 
			_consumer = new HTTPConnection;
			_consumer.observer.addListener(Event.COMPLETE, connectionCompleteHandler);
			_consumer.observer.addListener(ProgressEvent.PROGRESS, connectionProgressHandler);
			_consumer.load(new URLRequest("http://127.0.0.1:8081"));
 
			_log = Log.getLogger(this);
			_gui.appendText = "start\n";
			_log.debug("start");
		}
 
		protected function dataSendHandler(event:DataEvent):void
		{
			// TODO Auto-generated method stub
			var c:IConnection = new HTTPConnection(true)
			c.observer.addListener(Event.COMPLETE, function complete(data:ByteArray):void
			{
				_log.debug(data.readUTFBytes(data.bytesAvailable));
			});
			var r:URLRequest = new URLRequest("http://127.0.0.1:8081");
			r.data = encodeURI("msg=" + event.data);
			r.method = URLRequestMethod.POST;
			c.load(r);
		}
 
		protected function connectionProgressHandler(data:ByteArray):void
		{
			// TODO Auto Generated method stub
			var next:String = data.readUTFBytes(data.bytesAvailable);
 
			var o:Object;
			try
			{
				o = JSON.decode(next);
			} catch(e:Error)
			{
				Throws.error(e);
			}
			if(o)
			{
				_log.track(o.time);
				if(o.msg)
				{
					if(o.msg[0] && o.msg[0].msg)
					{
						_gui.appendText = o.msg[0].msg+"\n";
					}
					_log.info(o.msg);
				}
				//chat.text = next+ "\n" + chat.text;
			}
			trace("DUPA:"+data);
		}
 
		protected function connectionCompleteHandler(data:ByteArray):void
		{
			// TODO Auto Generated method stub
			_log.debug("data" + data.readUTFBytes(data.bytesAvailable));
		}
	}
}

And the gui class for display the messages:

package clazz
{
	import flash.display.Sprite;
	import flash.events.DataEvent;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.text.TextField;
	import flash.text.TextFieldType;
	import flash.ui.Keyboard;
 
	[Event(name="data", type="flash.events.DataEvent")]
 
	public class GUI extends Sprite
	{
		private var _txt:TextField;
		private var _msg:TextField;
 
		public function GUI()
		{
			super();
			if(!stage)
				addEventListener(Event.ADDED_TO_STAGE, init);
			else
				init();
		}
 
		protected function init(event:Event = null):void
		{
			if(!_txt)
			{
				_txt = new TextField;
				_txt.type = TextFieldType.DYNAMIC;
				addChild(_txt);
			}
			if(!_msg)
			{
				_msg = new TextField;
				_msg.type = TextFieldType.INPUT;
				_msg.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);
				_msg.border = true;
				addChild(_msg);
			}
			resizeHandler();
			stage.addEventListener(Event.RESIZE, resizeHandler);
		}
 
		protected function keyDownHandler(event:KeyboardEvent):void
		{
			if(event.keyCode == Keyboard.ENTER)
			{
				dispatchEvent(new DataEvent(DataEvent.DATA, false, false, _msg.text));
				_msg.text = "";
			}
 
		}
 
		public function set appendText(value:String):void
		{
			_txt.text = value+_txt.text;
		}
 
		protected function resizeHandler(event:Event = null):void
		{
			_txt.x = 0;
			_txt.y = 50;
			_txt.width = stage.stageWidth;
			_txt.height = stage.stageHeight - 50;
 
			_msg.x = 0;
			_msg.y = 0;
			_msg.width = stage.stageWidth;
			_msg.height = 50;
		}
	}
}

And that’s it. The exported swf size is wow 12KB, not much :)
Any questions please post in comments.
Sources are below, i will try to post my HTTPConnection class sources with others on github as soon as I will have some more time.
Just run twisted_stream.py in server folder and Main.swf in client/bin-release

twistedstream

Have fun :)