Flavors of Applications

[Left Right <ol...@gmail.com>]

This is going to be a very long term planning, and I don't expect any
immediate resolution, but wanted to hear your opinion anyway.

Reading through the framework code related to it's "developer facing" side
(i.e. the classes like SystemManager, Applicaiton and the company) I found
that:
- classes are huge... well, that's not new, but requires a special mention.
- classes contain code that is impossible to execute together. This
requires some explanation. These classes are built in a way that if you
used them in certain context, that a subset of features would be active,
while another subset, while still present, wouldn't be active. Consider
that any web application has lots and lots of code potentially usable only
on desktops - native drag manager, for example, but I won't list all of the
examples here, you'll have to trust me they are found in abundance. Not
only the code supporting different platforms and environments coexists in
one class, but also the code that supports RSL loading exists in standalone
applications.
- the generated code is absolutely impossible to regulate and the generated
code is of tremendously low quality. It's so bad it could have won Darwin
prize if it was nominated. Again, these are no news.

What I was thinking about is this:

- develop a transparent template system. By "transparent" I mean plain text
substitution or something equally simple - no XSL or frameworks like
Velocity, please - they make the templates unusable. Something dead simple,
yet something that would limit the compiler to _only_ modify the templates
to generate the final sources instead of creating files. It would be
cool(er) if AS3 had a preprocessor, but given the very complex syntax that
sounds like mission impossible... so I'd it be rather minimalistic, then
robust and buggy.

- create several templates for commonly used types of applications _and_
make it so that anyone who wishes to mod or add templates, given they
follow simple rules, are able to do so.
I could come up with the list below, but it needs not be exhaustive, it is
more of an illustration of what I think it may be:

web-application-{standalone}.as.tpl
desktop-application-{os}-{standalone}.as.tpl
droid-application-{standalone}.as.tpl
ios-application-{standalone}.as.tpl

{standalone} if present, means that the libraries are statically linked.
{os} if present, means the operating system this application is targeting.

It might make sense to include the spark/mx in the template (you wouldn't
usually want to use the two together, but the lighter version such that
uses only one of the two might be handy).

The template wouldn't include only the application class. In fact, there's
a lot of infrastructure found across different framework classes, which
would need to be isolated and externalized into the template where it
belongs. The benefit would be, of course, the reduced size and ease of
debugging.

I would like to hear your feedbacks before I post this to JIRA. The idea
isn't very new to me, but I put it in writing only a day ago, so it still
needs polish.

Best.

Oleg