A little less than a year ago I published a post (really a rant) on this blog entitled ActionScript 3.0: Not At the Children’s Table Anymore. It was directed at those who looked down on us ActionScript 3.0 developers as serious OOP and Design Pattern programmers. It was also an invitation to take up the challenge to go beyond Timeline programming and use all of the new language tools and structures available in Flex Builder and Flash CS3 and CS4.
My enthusiasm was based on my great admiration for ActionScript developers and my firm belief that they were just as capable as any Java, C# or C++ programmer. That faith has never faltered based on what I have seen on this blog and in ActionScript 3.0 creations. In fact, if anything, it has been reinforced. ActionScript programmers take a back seat to no one.
One of the problems with enthusiasm is that it can be dogmatic and sometimes misplaced. Trying to yank a six-year old from the proverbial children’s table is not a good idea. The six-year old is perfectly happy and has far more fun with the other children than sitting with a bunch of stuffy adults.
In the same way, through misguided enthusiasm, I believe I have tried to yank some from the children’s table of programming who have no desire to leave. They are perfectly happy creating sequential and procedural programs that get the job done and to them, I sincerely apologize. They are guided by such wisdom as, if it ain’t broke, don’t fix it and other similar thought processes that eschew the kind of exploration required for working with and understanding design patterns.
Simplicity and Simpletons
Of all of the wisdom throughout the ages simplicity is the most important and misused. In everything from understanding the art of war to simplifying the French bureaucracy, Napoleon used rationality and simplicity to achieve his goals. However, to me, the greatest piece of simplicity is Einstein’s famous formula:
E=mc²
What more elegant and simple way could there be to express that energy is mass times the speed of light squared?
I think that the secret to spotting true simplicity is through elegance. In a recent post I marveled at the elegance of the Context component of the Strategy design pattern. Yet the Context class is quite simple—a concrete class made up of abstract elements. In my mind it represents a perfect example of simplicity dressed elegantly.
As we all know a simple solution may be difficult to achieve. That is, simple does not mean the same thing as easy. Back in the old days, a programmer just coded one line after another—sequential programming. The programming part was relatively easy, but when it came time to add a new element or change the program, he was up a creek. Procedural programming was not as easy, but it helped to simplify debugging and organizing the program into discernable procedures. Then, along comes OOP, which simplified working with more complex programs but learning it was more difficult than either sequential or procedural programming. At the heart of design patterns is a set of very simple principles. As your programming tasks become more demanding, your programs are more difficult to change and update. However, if you use design patterns (which are difficult to learn) your update and change tasks become simpler.
When I hear dictums such as KISS (Keep It Simple Stupid), they are often voiced by those who have little or no understanding of the concept of simplicity. What they are really saying is, Keep It Easy. However, simplicity is really a matter of pay me now or pay me later. If we do not spend time learning more complex simplifying structures (there’s an oxymoron if there ever was one), we end up working much harder to unravel problems caused by an easy solution. So it is with design patterns and OOP programming. As GoF note at the beginning of their book, learning this stuff is hard. However, once we get it, updating and changing a program is easy.
Easy Does It Excellence
In a previous post on this blog, I attempted to differentiate the endearing quality of excellence from the stultifying attempt at perfection. Of all of my shortcomings (and I have many) impatience is the worst. Over the years I’ve had to fight the urge to get something done quickly either so that I can go on to the next thing I have to do or to get the results of the project. At some point I realized that I should enjoy the learning process. With design patterns and OOP, try enjoying the trip.
Those who have opted not to tackle ActionScript 3.0 design patterns at this time, shouldn’t. In fact, don’t even try. No one should be rushed into something like design patterns. Wait until either 1) a job requirement demands it, or 2) you want something that will challenge your mind. In our current economy, yes, you have an advantage if you know OOP and design patterns over some poor schmuck who doesn’t, but if you’re not ready, there’s no magic bullet. It takes time and effort.
Keep in mind that the children’s table is not a bad thing. Dragging a six-year old away when he’s not ready is not a good move. Enjoy your time with the other kids. I know I did. However, when it comes time to move to the next level, be prepared to work on it, and above all, don’t whine.
The ActionScript 3.0 Developers: The Children’s Table Revisited by William B. Sanders, unless otherwise expressly stated, is licensed under a Creative Commons Attribution-Share Alike 3.0 United States License.
Related posts:
Bill Sanders
This is a good, and well-considered post. I would add that the desire to learn patterns and move to a more sophisticated form of code probably happens around the time one gets a desire to not only do great work, but personally be the best they can be at what they do. There is a subtle difference.
Timbot,
I don’t think that you can have one without the other. So, yeah, that’s what I should have added. Also, it really makes you feel good when you’re inching along in the right direction.
Thanks for your insight,
Bill
This is an excellent well thought-out post. I also believe that you cannot push design patterns but passively encouraging its use for the curious onlookers is important.
I can’t wait until Flash starts getting more advanced syntax for OOP though…
Hi Jonathan,
Getting pushy with just about anything can be tiresome, and I need reminding of that as much as anyone. We enjoy doing design patterns, but we had to be ready for them before that enjoyment. Also, they are interesting puzzles which often require a certain type of inquiring mind. Fortunately, our readers seem to have those qualities.
Kindest regards,
Bill
I dont understand you people …
KISS priciple is bad?
What is wrong in keeping things easy?
This is madness …
95% of programming problems that average flash developer encounters can be solved without even using OOP. Selfish desire of perfecting the code by using fancy abstract constructs will bring satisfaction to the creator and make majority of others curse.
But who cares? The true value is elegance of the code itself …
Hello MrA,
Your response is as though I said there was no Santa Claus! What’s wrong with keeping it easy? Nothing. However, it depends on what you want to keep easy. If you want the ability to reuse code and make changes in a complex program easy, you will find design patterns to be quite helpful.
You are perfectly free to use sequential programming from now until the crack of doom. If you wish to learn OOP and the more advanced structures in programming in design patterns, it requires a kind of programming interest you apparently do not have. There’s nothing wrong with that, and I hope you find what you’re looking for. You just won’t find it here.
Take care,
Bill
Hi Bill,
My personal preferences in programming style have nothing to do with my post. It’s general observation – things are going in the wrong direction. So happened that routinely develop OO AS3 code from some time now. It was an intellectual challenge. Eventually I begun to feel relative comfort using flash.net.navigateToURL(new URLRequest(”)), external editor, versioning software and other stuff instead of single, self contained fla file. When I send the sources to the guy I was working with for years he said: ‘you must be crazy’ … that’s real life. Real life with misunderstood concepts, constant spec changes, low level hacks, code obfuscation, human ignorance, stupid bosses.
Why don’t you Geeks think of something that mitigate those factors? Something intuitive to let all those guys out there develop useful stuff? Why do you promote ideas that make the whole process even more complex? Do you know that over 40% of all IT projects are never finished? And why do you think is that?
regards
A
Hi A,
First of all, dispense with the name-calling. It doesn’t further your argument and make you look smart as you seem to think. Second, quit acting like you’re the only person who has a “real life” in programming. That’s worse than arrogance–it’s narrow minded. I’ve dealt with some of the most dirt stupid people you’d ever want to meet, and they all shared the same kind of arrogance. Everything we’ve discussed on this blog deals with real life and programmers and managers who have worked to set up a systems of programming to make the process as efficient as possible. If it doesn’t work for you or the people you work with; then don’t use it.
Wouldn’t it be wonderful if everything were as easy as you’d like to make it. It’s not. The world you want is “Real World for Dummies” –everyone does everything because it’s easy and fun. Unfortunately, in a highly competitive real world, that’s not the case. No programming technique can mitigate foolish decisions over which developers have no control. The larger the programming task, the more programmers need sophisticated tools. Unlike flipping burgers for a living, the techniques are not easy to learn. This is not easy stuff, and if you’re working with a bunch of people who don’t understand it and don’t want to take the time to; then develop your own systems. No one’s stopping you.
For me, at least, I’d rather listen to some very smart people who have worked long and hard to develop techniques that do work in the real world. Clearly, you’d like something nice and simple that everyone understands–like the kids who flip burgers. Where do you think that a nice simple programming language comes from? The programming fairies? No, it comes from people who work through these problems or take existing OOP languages and create structures that are easy to update and maintain.
If you would like to use ActionScript to create a single script using the Action panel, we’re not stopping you. I agree it’s easier in the short run. Just like flipping burgers.
Kindest regards,
Bill