A New Flash Framework?

I figured I’d take the spare 30 minutes or so I have at the airport to write about an idea I’ve had for the past 2 weeks. Any seasoned programmer will see duplication and seek to destroy it. I’ve seen duplication in the Flash work I’ve done over the years and I want to provide a better way of doing things.

Some context. I went from being a Flash Developer to a Flex developer in the past 2 years because of workflow & industry norms. The workflow in Flex from a programmer’s perspective is superior to Flash’. Additionally, the typically jobs one gets using Flex have extended deadlines compared to the typically design / deadline driven worlds of Flash work. Thus, you have more of an opportunity to apply tried and true programming concepts when creating software. Make no mistake: Both industries create software. The Flash websites and the Flex intranet apps all have similar goals of creating GUI controls, connecting to back-end data via middleware or static data such as XML, and require code to make those things happen. The difference, at least in my experience, is deadline. In the past, it was price. Now that Flex is now priced within the reach of the majority of companies, as well as the framework & compiler being free for those who do not wish to use Eclipse, true options exist.

To me, though, the lines really aren’t that blurred. If you are in the creative industry, you’ll continue to use Flash, and if you are in the software industry, you’ll continue to use, or start to use, Flex. Granted, there can be mutually beneficial crossover, hence the point of my presentations the past month & at Adobe MAX this year.

There is a problem with the Flash industry, though. Flex has 2 frameworks, ARP & Cairngorm, deadlines that support such large project scoped frameworks, and code only based approaches to development. Traditional, predictable, diffable, ASCII, and centralized.

Flash is none of those. While it has ARP, and a variety of other component sets and frameworks, each addresses a singular problem, and doesn’t scale, those that I’ve battle tested. For example, ARP is a great framework for Flash, but when you have 4 weeks, and are only reading data from the server, it’s hard to justify writing 6 classes just to load an XML file into a text field. My current project, for example, has a hardcore set of priorities. I’ve written them on our whiteboard in the corner for our team to refer to in conversations. They are, in order of priority:

  1. Deadline
  2. Creative
  3. Bandwidth
  4. Maintainability

As you can see, that is an extremely harsh reality for traditional software developers. Most would look at that and reply, “F that”; probably more tactfully. Most do, hence my continued employment in this industry. Anyone who has done more than 1 software project knows NOTHING is on time. If it is, something is wrong with it. Software Development is an art, not a science. You cannot place a deadline on a subjective endeavor. It is merely for team morale, focus, and business acumen.

Secondly, most all programmers are interested in developing for maintainability. As you can see here, it is the LAST thing we think about. The Flash world in some circles has indeed reached the coveted “disposable software” stage coined by I believe Kevin Lynch back in the Central days. If you are going to throw the software away in 6 months, do you really care about encapsulation, OOP, and strict typing? How much is really enough and how much is too much? Where is the defining balance?

The flip-side is things like prototypes and “tracer bullets” (Pragmatic Programmer) become a way of life, not tools to develop software; they ARE the software. They are “good enough” for the job at hand, are completed (generally) when the deadline comes, and are cast aside when the next site refresh arrives. The attitude one adapts for creating a prototype, like letting strict-typing slide, breaking encapsulation, and other minor points of good software development give you a burst in speed in development. Some have argued that strict-typing does in fact help them code faster. I’ve never seen those comments, however, flushed out. Faster how? Faster to debug? Does that equate to less overall development time? What if you never had to debug? Would it matter then?

I contend that as long as your magic strings are numbers are var’d, you’re good to go, strict-typing be damned. I still use it, though, because I can type fast and it’s just a built-in habit since I spent years learning how to make it one. Kind of hard to unlearn something you devoted half-a-decade to ingraining in your everyday routine.

It’s got to look good, not work good. Meaning, if it works well, but doesn’t convey the brand, doesn’t correctly represent the Art Director’s vision, or doesn’t sell the product in someway, then a working list box is useless. To a programmer, that’s harsh. Suddenly, you are given the impression that all of your hard work, creative problem solving, and talent was for naught. It’s frustrating, makes you 2nd guess yourself into insecurity, and develop an apathetic attitude towards tasks you used to get excited about. When the color of something is more important to the functionality of something, it requires a major perspective adjustment. Some rules are suddenly meaningless, some ideals become ivory tower ideals, and some workflows degrade into “programmatic barbarism”. That’s ok. If you complete it on time, and the designers are happy, you win. Success is defined by hitting the priorities above.

Bandwidth is the most harsh of all. When you are removing loading bars just to grasp at every minute once of “speed perception” you can see to what lengths people will go to keep it fast, or keep it looking fast. This pretty much destroys most battle tested Flash Development strategies. Suddenly, you can’t use a single SWF that preloads everything on frame 2, classes included. When loading bars are bad, things become less in touch. Things in Flash less in touch are inversely proportional to the amount of developer / designer maintenance of the assets. For example, a single SWF is easy to maintain. All code, all internal assets, and symbols are all in the same FLA file. Flash the IDE is made to help navigate the FLA format and organize it. Programmers have dissed FLA’s for years as being binary, and thus impossible to diff via source control, and various other problems. Designers have always known, however, how useful they are for keeping needed assets localized, not forced to map to the actual project folder structure in which the FLA resides, and the flexibility to make another one load another one.

This is a programmer’s nightmare. While Remote Shared Libraries are a great idea, there are no good tools to make them easy to manage. When people like Darron Schall have a bead of sweat fall from his brow upon “getting them to work good”, you know you have a problem. So, what is the best way keep small, quickly loadable SWF’s without causing code spaghetti? Exclude files. As long as all SWF files are from the same sub-domain, they can share classes. The classes don’t have to physically exist in the SWF itself, they just retain pointers to their names and have faith they’ll be available when loaded into a base SWF who DOES have them. An exclude file is an XML file that defines classes that you don’t want compiled into the SWF when you compile. It has the same name as a FLA and lists all classes you don’t want in the SWF. The Flash IDE will check for the existence of this when you test movie / publish / compile.

One technique that I’ve seen is to basically spell out all of your classes into the _root of your FLA without imports. Flash interprets this as a usage, and thus will compile the class into the SWF. This FLA which has no library contents will merely have classes in it. You can optionally put a function on frame 2 that emits some sort of event or calls a function in the _parent to alert those who care that it’s ready to be used as a “DLL” of sorts. The base SWF then acts like a Java Classloader of sorts, and loads this bad boy in first, and then loads in those SWF’s who depend on that framework.swf.

Finally, maintainability is the last thing we think about. As you can see, all of the above does everything it can to pretty much sabotage any hope of maintainability. Really all that matters in this line of work is it being maintainable enough until you get done with production, and out of QA. At that point, smoke ’em if ya’ got ’em.

As you can see, there are a lot of challenges to doing Flash Development compared to Flex Development, with very little conventional solutions to tackle it all in one fell swoop. Those that do exist don’t account for the common situations and challenges listed above. There is no fallback plan, no Plan B when the deadline starts to squeeze, no exit strategy when you’ve coded yourself into a corner to please your designer overlords.

What has tried? A variety of things, and some I’m sure I don’t know about. ARP did a lot to get Flash Developers on the right track of using a framework which has a ton of benefits across the board. ARP does not, however, currently possess a conventional, documented practice of using it across dynamically loaded content.

EnFlash is a really neat Flash component set that has a lot of the content dynamically drawn. Since you cannot share assets across Flash Player 8 libraries are runtime in normal way (there are weird ways to use bitmaps and sounds), EnFlash works well because there are no design dependencies. The problem? All Flash Design work I’ve been involved in uses dynamically drawn, customizable vector gradients 1% of the time. Everything is a custom design, everything has usually already been documented or spelled out in the comp by the designer, and thus all of those code is useless.

Most of the component sets I’ve seen and had the pleasure to use were built to satisfy a different style and perception by their developers. mCom (aka Glic) was built to utilize some of the common programming concepts Grant Skinner and friends enjoyed. The Bit components by Keith Peters I’ve also used as well. They were actually very skinnable. Not skinnable enough, however, from what I’ve played with. Additionally, anything that doesn’t do the same thing as Macromedia’s framework causes licensing issues as well as skill transference issues. For example, while I personally found the Bit components easy to get into, when you have 4 weeks, it’s a big risk to take having your developers learn a whole new set of components. Furthermore, a lot of designers don’t give a flying flip about “components” and thus don’t build to their specs. For example, I’ve yet to find a designer who gives me the 8 states I need for the Button component, Flash or Flex. Should they? I’ve found I’ve always successfully implemented a designers vision when I coded to the design, not the other way around. That is a horrible thing to do programmatically, but I direct your attention to the aforementioned list. For example, “I don’t care that the border is a rectangle built dynamically upon focus in mx.skins.halo.RectBorder… just make the damn border always glow yellow with the bottom left point, and do it by the deadline!” is a common frustrating interlude between the two disciplines.

There was often a confusing response to questions about “using components?” on the Flashcoders mailing list. Some would quickly respond, “roll your own”. Those of us who were learning to utilize the built-in functionality would cringe at the poor souls writing code which was already written for them, but was either poorly documented so they didn’t know it existed, or just didn’t have time to learn about. This, however, was a clouded perception. Some of us, at the time, were splitting industries. Some were remaining in the design driven world where others were heading into application development. Those are 2 very different disciplines with very different perceptions towards components, both very valid.

Therefore, rolling your own is definitely justifiable when there is a snowball’s chance in hell that you’ll “get to work with the designer”. Some companies are setup with that level of team accessibility, or where the designs are outsourced to some contractor you’ll never meet nor talk to. When a client signs off on the design, you can pretty much ensure that the fact that the component you are using only supports 4 skins only confirms your late nights of creating a new one that does the same thing, but works with the design.

This isn’t sad or a broken process, it’s just the way it is in some companies. You either get stressed the f’out and leave, or find a way to make it work.

I’m interested in finding a way to make it not just work, but work better. While I have no intention of continuing my career in Flash Development vs. Flex Development, I certainly didn’t expect to be doing Flash work in Detroit once I signed up with a Flex Consulting firm either.

I’ve always been pretty sure I’d never want to be involved in framework development. There is too much drama, too much time spent in meta-programming discussions that one is hard pressed to find value in at the end, and overall very little reward for all the hard work put in, at least in my perception. For example, it’s easy for me to bitch about how Cairngorm is implemented in some sections. I have the luxury to pick it apart, and mod it for my projects to my hearts content. I don’t have to worry about backwards compatibility, developer API understandings, and various other community future implications that Steven does. To me, it’s perceived as a thank less job that does a lot of qualitative good that can sometimes be unfairly overshadowed.

I have a feeling, however, that there is still some things I contribute that would help at least alleviate some suffering I’ve personally experienced, I know others currently experience, and some will continue to endure into the foreseeable future. There is a certain set of principles you can develop to in Flash, but scale up and down to your deadline, your design’s intricacy, and your team’s size & skill set. The latter I can’t really do much about. I’m not into training, and it’s a lot to ask someone already in a high pressure environment to change the way they do things.

There are a myriad of problems. There is no component set I’ve seen that was specifically built to be shared across multiple SWF’s. I think Aral Balkan, Peter Hall, and some other dudes actually separated the MX 2004 framework to be in single SWF’s to prevent the large initial download size. The problem? The framework was built to use styles. This implementation brings with it a TON of extra file size that isn’t needed in an environment that already uses it’s own design based on pre-created comps. The way one builds components isn’t really defined, and the ones that are don’t really scale to git r’ done scenarios. For example, while the Flex 2 way of setting dirty flags, and then redrawing your component once per frame is great and built specifically for the way the Flash Player works, it’s certainly asking a lot of already time pressured developers to double the amount of variables in their classes via a set of dirty flags, 1 per settable property, extracting redraw functions into 3 sets, let alone optimization in general. Most don’t have time to think, let alone think about optimizing.

Is it even worth it? I feel like this kind of work will in fact continue, thus there is value in contributing to making a workflow & framework that fits it. There is definitely a need for a framework that is specifically built to satisfy the following goals:

  1. Usable via multiple SWF’s.
  2. Small file size.
  3. Supports beginner and advanced component developers.
  4. Packaged utility classes for common scenarios.

Why those 4? Let’s elaborate.

Loaded movies are very important to design intensive Flash sites. During development, they allow multiple people to work on disparate elements at the same time, thus increasing productivity. Secondly, they expedite creating assets that take longer to compile. For example, using Flash to compress your sounds to mp3, a lot of images, or embedded video can greatly increase the amount of time it takes Flash to make your SWF. Being forced to go through this long compile time just because you changed 1 line of code is unacceptable during deadline driven development. Thus, you can create a SWF with the media content once, and merely load it later into some more volatile to develop section. This also makes it easier to update later without having to recompile the whole thing.

At runtime, loaded movies help lessen the download damage. Instead of downloading the parts of the site / app the user won’t see till they actually navigate there, it works much like a webpage and downloads as needed. This allows a multi-meg site to be given in increments yet appear fast to the user.

Small file size is important to ensure the above is successful. One of the reasons the MX 2004 & 8 framework is so big is because of styling. Both the symbol assets as well as code behind it adds a lot of kilobytes that a lot of designers will never use. Granted, the font control is nice, but the trade off in file size isn’t worth it. Since a lot of sites are custom designed, styling is to generic of an implementation. You are typically using custom image assets garnered from a Photoshop or Illustrator file that a designer has already created. The colors, fonts, and styles are already done and decided upon. Most won’t be dynamic. If it is, the designer has already created it.

Secondly, the site is already strained from using image assets above that have to be embedded bitmaps and not loaded externally, especially pre-Flash 8 where you can only load non-progressive JPEG’s at runtime vs. GIF’s & 32 bit PNG’s in Flash Player 8. Since the only real optimization you can to code is compression via LZW, you have to ensure the code you do write does just what you wrote it to do, and nothing more. Flash does help you some, like not embedding imports that you don’t use, only including a class once in the same SWF, and the ZIP compression is pretty good on duplicate includes. Regardless, the designer created content has already taken up most of the bandwidth room; there is very little leeway for code in the already tight space.

Flash Development attracts a wide skill set from animators, compositors, painters, and good ole designers. You also have the other side of the fence where back-end developers are utilized as temporary front end coders for Flash. They have their own background and coding style. Thus, the level of code ability varies wildly, and is hard to predict. It is important, then, to allow the beginners to code with simple to understand methods, and easy ways to “make it work”. It’s hard enough to enforce the no code on frames mentality; the least you can do is make your classes easy to use for those who don’t have a lot of time to learn them. On the same token, it is unfair to codify traditional programmers into intentionally non-efficient methods if they know what they are doing. For example, one of the ways to modify how View’s are written in Flex 2 and Flash 8 is to simple ignore dirty flags, and instead just redraw. So you call the resize function 3 times on the same frame, thus making 2 of them useless since Flash Player only redraws once per frame. Is that REALLY that bad for a component that just shows a label in a nicely designed panel? I’d say hell no, no problem, move on. In a Flex app, you’d quickly go, “Nope, you need to set a dirty flag for the label, call invalidateProperties, inspect it in commitProperties, and call any setters or invalidation routines there to ensure efficient redraws.” That is overkill for a lot of Flash projects, but there are justifiable use cases where you have a really big and/or complicated component that could benefit from such efficiencies. If you have the code talent on hand, why not utilize it? Designing view classes that allow beginners to easily code their views as well as programmers to go all out, and have both play nice with others is a challenge, but can be done with a few conventions. This also allows everyone to easily fallback to a more simplified coding style when the deadline tightens the noose.

Finally, including a set of utility classes, with a Creative Commons license, to accomplish the most common tasks that Flash Designer & Developers are faced with in Flash sites is the final touch. It’s one thing to establish a set of coding standards, it’s another to have helpful code. Having code handle common tasks ensures you can handle the more important problems you are having with a deadline vs. re-writing the same function queue for the 5th project this year.

The cons? Training. Yeah, you can document a framework, but I’ve found it most rewarding to work with people to show the pros and cons of a particular way of development, especially compared to the way they traditionally do things. In doing, they recognize value in the new way. Second, you empower them to train others, and convey that value in a language they understand, typically in some context applicable to their business and/or type of work.

I’ve also found it hard to get people to change the way they do things when they already have no time. Taking big development change risks is a major deal when you are always behind. Being able to integrate framework B into an existing framework A is challenging, and is sometimes the only way. Just like how programmers constantly refactor, so too is the way you can implement a framework bit by bit, assuming it doesn’t have a lot of dependencies preventing you from doing so.

Finally, there is currently no easy way to create exclude xml files and keep them in sync. The same management nightmare one gets with Remote SharedLibraries is the same thing you’ll eventually get with exclude xml files. Is this class still valid? Did I refactor it and change it’s name? Does it really belong in this SWF?

I think the challenges are no small thing. The amount of information that describes how to do things could fill a book based on my experience which unfortunately is aimed at people who don’t have the time to read a book. New tools (Flash Panel?) would have to be written to help designers and programmers stay focused and help them accomplish their goals.

Hopefully at the very least I can keep blogging what I’ve found to be the good and bad decisions since Flash Development is fraught with subjectivity.

22 Replies to “A New Flash Framework?”

  1. I have to say Jess, that’s been by far one of the best reads of this month in the blogosphere.

    I think personally, the position folks are approaching FLEX is a little to ‘old skool’ and at times need to not only take a page out of this post, but reflect on what the technology they have in front of them really does. You’ve touched on how FLASH can be a beast to master, but when mastered can pay rewards if used in a throw-away manner. Yet, the moment you try and bring in some of the traditional software development approaches, then you find yourself stuck in this technology void.

    Throw-away software would pretty much summ up the approach taken with FLEX and FLASH. I think we all need to let the technology digest for a couple more years before we start talking about patterns and oop theories on re-use. That’s really the main reason i’m not a fan of Cairngorm as it answers too many questions up front and not enough ‘lessons learned’. That and I think its approach in FLEX 1.5 was kind of there, but in 2.0 it feels as if its simply ignored the ‘new way’ of AS3.

    Yet as you put it, we all have the benefit of poking holes from the outside instead of being in on the inside, producing something thats an alternative approach :)

  2. Jesse- another great post. That is where my industry is stuck right now with flash. There are not enough dollars for a flex-like deployment so we end up with disposable code-or another way to put it is we build new prototypes for each job. Reuse is hard to come by-i’ve looked at ARP but when i fit it into the spreadsheet it translates to not getting the job.

    I DO think there is ground to define between total timeline procedural code and the OOP frameworks. A lot of ‘good enough’ is successful because it gets the job done. This is where the Ideals and the Realities start to Rub. Is a framework always the answer for a decent size deliverable-i would say no.

    Another whole side of this issue is the actual content-for example if i have and interactive animation of a Toyota EVAP system with slider to simulate more or less sulphur in the exhaust and how that affects the short and long term fuel trim in a dynamic scan tool wave form-will ARP or Cairngorm help me with that? Probably not. To be honest i don’t think there is a way to remove all programming from the timeline in those instances. The code is working so intricatly with the vectors and bitmaps involved you can’t seperate it. THis is where i think we are in relation to ‘design-y’ flash stuff that does have a framework of sorts-the above example had to send out events when the student put the sliders in the correct position-the events where listened to by a much more OOP like code set. You have to figure out where (navigating the Void that Scott speaks of) the two types of development do the most for you and make them somehow mesh together.

    Navigating that Void is where i see your idea of a flash framework fitting in. Also i seen postings that Adobe is working on how to make complex animation more structured and reusable via the flash 9 ide. What that means i have no idea.



  3. Flash 9 offers useful features, such as being able to load a external SWF and use its symbols at runtime through the application domain stuff. Considering that it might take a while to develop a good framework, consider that Flash 9 should be ready for primetime with these sort of marketing projects by the time it’s done.

  4. Flash Player 9 is already done, Blaze is not (Flash 9 IDE). The only addition is getClassByName. While that makes it easier, you can already do the same thing with ‘implicit’ knowledge of the SWF, or just do a for loop through _global to find the classes you need.

    All players, however, will need a framework and toolset to support exluding of classes, and smart inclusion.

  5. Jesse, I think you misunderstood me. You mentioned the issues of working with component frameworks in these gotta-be-done-now Flash projects. I’m specifically addressing the issue of working with the art for these components.

    In Flash Player 8 and below you can’t load the art from other SWFs at runtime. This is typically the largest part of your SWF, so it would be beneficial to load it only when it’s needed. In Flash Player 9, they’ve added the flash.system.ApplicationDomain class which lets you load classes at runtime from external SWFs. It can be used to load embedded symbols too.

    That’s why I suggested targeting Flash Player 9. A part of the framework could be designed to allow loading art assets from external sources.

  6. Hey Jesse, I completely agree about the overkill when applying best-practices to ‘throw away code’. I remember back after having learned all about MVC I really started making simple projects more complex just because I thought I was doing it ‘right.’ Well it didn’t take long for me to realize that ‘right’ needed to be in-context. I have since been more practical with my implementations, making applications only as complex as they need to be and not a bit more. When you juggle concurrent projects and one needs to be a long-term supportable application and the other a throw-away promotional sitelet it’s easy to get caught up in overkill on the later. In an upcoming blog post I’m going to talk a bit about an ‘MVC Lite’ design pattern that I’ve come up with to kind of have the best of both worlds; throw-away code with an easy to implement design pattern. I’ll post a trackback when it’s up.

  7. I did mis-understand you, yeah, sorry Josh. The ‘everything is a class’ nature helps a lot, and I’m sorry I mis-read that, my bad.

    The problem with 9 is that there are still clients on Flash Player 7, like the one I am on now. I think a lot still will be stuck on 6 through 8 for a long time, thus it I think it justifies the time a lot.

    However, planning for the asset sharing of Flash Player 9 is a definate must, thanks for clarifying on here!

  8. Player version is definatly something to keep in mind. THe larger companies that i work with tend to be very slow on the upg path. I have only one that targets 8-the rest are 7 and 6. The use of a systematic exclude structure woulde be very helpful. We ususally have 3-4 developers working on the ‘page’ content of our courses at any one time. I often set up the templates with the classes that will be in the base swf so that they can test as they work. Having to launch the course and navigate to the 45th page is a pain! The flip side is that we have o sweep through and comment out the lines at the end. I wonder if there would be a way to use the flash project panel as a ‘container’ for the excludes to target. Maybe it has hooks that could be used that adobe already built. At the least it would be interesting to see if adobe has this hybrid development on their radar as something to look at.

  9. I think the issue of player version is not to be underestimated.

    In reality, I believe coding to 7 is the most reasonable practice. It has 95% penetration, is available on Linux, and supports the standard v2 components architecture, warts and all.

    Personally I see myself coding for flash 7 for another year or so, unless I’m doing an in-house app where I can control the environment. As much as I like AS3, I can’t see targetting flash 9 for a while, though it seems to offer many features I like. Especially asset sharing.

    In short, part of flash’s bad rep is that the plugin breaks the seamless flow of the web. Demanding that users upgrade just to see your site continues this unfortunate trend.

  10. Nice discussion Jesse. I think I agree with most of your points but have some additional thoughts on a few:

    –it’s totally possible for a software project to come out great and on time. It’s really quite simple: plan the project appropriately and manage it well. (I will admit that of the many projects on which I’ve worked probably less than 10% came out on time–but usually this is because the managers extended the deadlines. Also, it’s quite rare that programmers cause the delays.)

    –you point out two good reasons to use the built in components (unknown or hard to learn). There’s another reason: they can be hard to debug… you’re depending on someone else’s code which (I’ll admit rarely) could be whacked.

    –compile time is a bitch. And while I use similar pre-rendering approaches to save time, really, those long test-movies cause more pain-and-suffering than actual development time. I guess it adds up, but I’m saying it’s a stress cost more than anything–and who wants a grumpy programmer?

    –there’s a very real reason to avoid many of these components and frameworks: some clients demand that you can ensure the code is free-and-clear of any other people’s work. They don’t want anyone popping up later to claim ownership on parts of the code. While I can see some values to open source, I also see how you can become dependant on some dude in dorm room or something… it’s just a little scary. And, I’m not saying using a reputable company’s code will always protect you either.

    Finally, you didn’t seem to discuss testing and overall stability. That seems to be a big part of a project’s success. The whole idea of ‘test driven design’ where you do the programming with the test requirements in mind is a really great way to go.

  11. My concern with Flash Player 9 is that there is no defined framework getting designers & Flash developers who typically use Flash ready for when they do move to 9. Because of the copious resource issues that Grant Skinner and others have pointed out, it’s frightening to know that suddenly people will just have to suddenly start dealing with these things.

    Hopefully if I could get people used to ‘cleanup’ functions it wouldn’t be a big surprise that to get the new Player 9 code speed, you’ll need to clean up some of your mess as well. Hard to do in deadline driven environs, I know.

    The whole point of using a Creative Commons license is that all you are technically required to do is keep my name in the code base. You are allowed to use, modify, and sell the software all for free. I need no license fees whatsoever. You have total rights to use and modify as you see fit.

    Testing & stability are not really worried about in a project where you don’t have time for such things. You are too busy creating, so testing is usually done with the week or less you have for QA. Stability is unfortunately an obvious problem each time because you are coding to get it done as fast as possible, not coding with good practices in mind. That very approach ensures your code won’t be up to hardcore battle testing and might break easily; it needs to work ‘well enough’. Since most people in these types of projects don’t ever do such things, that’s why I didn’t really talk about it.

  12. Really nice post, my comment is maybe a little of topic, but what I especially liked was the pragmatic approach to getting things done.

    Some of us are a bit ‘humbled’ when we see all this picture perfect framework like code everywhere, when what matters most actually is getting the current job at hand done, not the next.

    Nice to see that others also use a similar approach when it fits the bill.

  13. Phillip, i think one of the thrusts that jesse was making here is that to make the job profitable in this particular industry the appropiate management of the job was to NOTfollow one of the heavier frameworks and maybe it’s time to try and develop a different lighter ‘get it done’ structure. One that helps in certain places and stays out of the way in others since these jobs would be one-offs with little hope for future updates/additions. Possibly dumping some of the heavy upfront dev work for a more pragmatic approach to a framework. Sort of a ‘Good enough framework’ vs ‘an Ideal framework’. Dovetailing it into the realities that some projects must be thought of as throw away when working in the flash ide and at the same time trying to build some kind of overall pattern.

  14. That makes total sense Ethan. I guess that point was in Jesse’s post but I got bogged sown by some of the other details.

    I do tend to believe that frameworks (almost by definition) have inherent costs and negatives in balance to their benefits. Personally, I adopt the process of ad hoc ‘frameworks’ which I suppose aren’t really frameworks because they’re often one-offs.

    So, I like the idea of a (pipedream) ideal framework that perfectly fits every project I have; is lightweight; is easy to learn etc. Short of that, I think we can perhaps find a framework to fill the void (somewhere between hardwired everything and using a complex and heavy framework). The idea of optionally de-selecting certain unused elements in a framework is a great idea. We can probably learn from some of the countless AJAX frameworks coming out.

    I wonder how much a framework has to match the particular job type. Jesse works on very different projects than I do–but there’s probably some overlap in our needs.

    I’m curious what people think.

  15. Great post Jesse. I think a framework like the one you describe would be extremely useful to many Flash developers.

    Sometimes I use parts of ARP as a quickie framework. For example I will base the application on Arp forms and use the controller and command pattern, but I won’t bother with setting up service locator or business delegates and such. This allows me to get some of the benefits of ARP without taking too much time.

  16. Very nice post and very long. Too many ideas , too many emotions about the industry as a whole …
    I want to focus on the title of the post though …The reason for that is that we ( gugga ) have something new to offer as one put it ‘free of charge’ and hopefully without alot of programmer bravado.
    Because we have felt the pain of creating projects on a tight timeline and then year after year to have to extend and support them.
    That is why we had to create a flash framework of our own ( http://www.gugga.com/flashblog/ ).
    Because none of the existing frameworks covered what we do in the field.
    What we did is written in AS2. We will eventually move to AS3 and will probably be heavily influenced by Flex 2 and MXML concepts and will try to apply those not to applications but to rich interactive web sites. There is a big question open for us, is Flex II wtih MXML capable platform for building rich interactive experiences oriented more arround presentation then data.
    In our experience even the small projects can be build quickly and efficiently and most of all with guaranteed quiality. This is a fuction of your team , workflow , development environment, methodology, dedication and last but not least on the framework of your choice
    Quality is never an accident.
    If anyone as a flash developer questions the need to use OOP , sound design methodlogy that supports code reuse and does not draw paralels with the rest of the world that writes software then he is far from software development as a whole.
    Flash is already a platform for developing software. Very engaging, very interactive with a reach for the highest design standards but is a software platform. I think its time that we show the rest of the industry that Flash programming can be as mature and egaging as the rest of the technologies out there.

  17. Really interesting post with a lot of thoughts and ideas being bounced about. My personal take on it is that it is something that will only be answered in due course. I think the duality of having a tool traditionally associated with creating interactive cointent married with an emerging application platform throws up a whole heap of questions in itself. Although flash has been about for 10 years now I think it’s still very much in it’s infancy. There seems to be a fewOOP frameworks and design patterns that are, as previously stated, providing answers to questions that havent quite formed yet.

    Like, I dont think the goal here is to show everyone else how mature the flash platform is simply by applying traditional design patterns and frameworks to flash production simply because I dont think it will work. I mean I’m not saying throw OOP out the window but just that the amount of time spent meta-programming and leading developing for a developers needs to be re-addressed.

  18. nice post. i agree. these are all real problems dudes face. personally, i really hope flex 2+ addresses all the things we currently still need flash for. i swore off flash development a few months ago and then heard you did too. is the firm you are at making you go back into it?

    one of the things i’ve been talking to clients about is no longer doing their project in flash. development can be done quicker (saves money in the short and long run), more maintainable, runs faster (currently) and blah blah blah all the benefits of flex.

    if i was you. i would say, look dudes, i dont do flash. i’ll help you maintain or bug fix current flash apps but i’m not doing any new development in it. if you dont like it you can kiss my @$$.

    i think all of us flash software developers should go on protest until we can program in flex. start the revolution jesse!

  19. Yes, Judah. The gig up in Detroit required someone with Flash experience who was not only a coder, but who had worked with designers in the past so had process experience. So, while I swore I’d never do Flash dev again, hear I am up in Detroit doing so.

    I would say that, but there were 50 things that preceeded me. First, the site already existed and took 18 months an outside vendor to build. Second, of those 18 months, the in house development staff had created a multitude of web services that had already proven their effectivness. Third, someone from my firm had already put their stamp of approval on the quality of the code base from a business standpoint. Fourth, it works, and has been working for 10 months. Fifth, they probably spent milliions on it.

    So, me going in there deciding to re-do everything in scratch in Flex with the above in mind wouldn’t fly.

    Doesn’t mean I still don’t try, hehe!

  20. Hi!
    I am making quiz using flash. My mian movie calls diffrent moviclips through popupmanager. It has 13 questions 20 mp3 files [total duration 14 min] I use linkage identifier to load moviclips in window component.

    its taking 30 min to compile can you tell me is there any other way to reduce this time?


Comments are closed.