Here’s one. Its pretty simple and straightforward as well as being a fairly typical sequence.

Loader > Intro > Main > Loader > Sections

I think like I said one of the things I’m curious about is Global control and monitoring of actions that are taking place within sections… oh a Video is being played stop music, a link was clicked stop music and video. The other thing is passing of data between unrelated things. Main loads a master xml… knows to load a video for next section… plays next section… next section grabs xml from Main.

I guess what I’ve been starting to see is that for components with in the site I can pick out a design pattern like for the video component, or wallpaper switcher, sound controller, photo swapper/enlarger. But then the piece I can’t see is how to then link all these together and be able to monitor them all in the Main/Client cleanly without sending arbitrary commands back and forth and always checking thing’s with if statements all over the place.

One of the problems I had to unlearn was tightening up my code–I had to loosen it up considerably. Also, I found it helpful to drop the name Main and use Client instead. (I did this simply because GoF uses Client as the name for the class that made requests from the classes in the design pattern.)

For the time being, forget there’s anything like a global variable—in fact, let’s pretend they don’t exist. Also, for the sake of argument, we’ll also pretend that GoF never introduced the Singleton.

So here we are with the key question, What varies? You want to turn music on and off; so, you can see that state varies. Further, you have a number of objects that depend on another object along with how the dependent objects stay up to date with all of the different videos and images. Another way of putting that is you have a situation where the State and Observer designs can be of help. With those two patterns, why not make a MVC? (Or a PureMVC?)

For a long time now, I’ve wanted to create a relatively simple MVC for the Lunch Bucket series (design patterns you can take to work) and your kind of project sounds to be a perfect candidate—albeit a scaled down and simplified version. The goal would be to coordinate video play, photos, download and sounds. (This might suggest that we’re dealing with families of product objects that vary, and hence the Abstract Factory, but with the MVC there’s the ability to include more than a single design pattern.)

The goal is to create a design that would be easy to update and changes don’t domino fall throughout your project. Does that sound about right? Send a URL that shows the end results, and I’ll put a just the basics MVC together to do the same thing. It will call on the following:

1. Graphics (in SWF and graphic formats, I’m assuming)
2. Video (progressive download or FMS?)
3. Sound (MP3 files)
4. Flash animations (in SWF files)

Is that about right? I don’t want to know anything about your code or your current setup—just what you expect for an outcome and for maintenance.

Kindest regards,
Bill

I guess my most common task would be a SoundController (which I could then relate to several other tasks). Here is a typical set up.

Main.SWF
———-
Contains SoundController
Loads Section SWF’s
Plays Main MP3

Section.SWF’s
———-
Loads Video or Photos or Downloads ect…
Triggers several Sound FX and perhaps a new main MP3.

I need all sounds in my website to be able to be turned off all at once from within my Main.SWF, triggered from several different Section.SWF files, and I also need them according to a variable be retained in memory so I don’t have to burden the server over and over for a sound file that is used more then once.

Without wanting to pass references to a newly loaded SWF immediately upon loading it to be able to use the same SoundController. I know I could also use Getter/Setter but then I also need an easily obtainable reference to the Main.SWF which houses my SoundController. Would it not need to be a Singleton, otherwise it would not be able to be turned off Globally from 1 spot and also not use the same ‘memory’ table.

Without knowing what your projects do and how they’re set up, it’s impossible to say where a Singleton may come up and bite you. I just don’t like the possibility of an IED in my code. Further, while you know of no other way to do what you’re doing, we both know that some bright light will come along with a better way that neither of us thought of. It may be with a design pattern or not, but most likely it will be an OOP solution.

The issue has never been that Singletons don’t work. They do. The problems are more subtle and as you note, you don’t see the problem with global variables either. They have creepy characteristics that will get you sooner or later, and I avoid them because of that. However, you can do things with globals that you cannot do otherwise. The problem is that if a global can achieve a task that nothing else can, you’ve probably picked an non-OOP solution.

I think a lot of us end up using non-DP solutions because it just takes too long to work out a dp solution, or you have a solution that has worked well without any problems and the time and effort to change are too great.

As we muddle our way through all of this, we improve by nano-degrees, and all of us want better code. That’s why I brought up the limitations and problems with using Singletons.

Ironically, at next month’s OOPSLA meetings I’ve been asked to deliver a presentation on where a non-OOP solutions works while an OOP solution doesn’t! (The author of the paper has to be away judging a Computer Science competition.)

Here’s an idea. Let’s take some project you do and find a DP solution for it. It can be an old one (and something small!) so you won’t get into contract trouble. Then we can explore something practical and possibly come up with the kind of solution you’re seeking.

Kindest regards,
Bill

Now maybe its because of the type of things I am asked to develop but I have to say I use a Global Singleton at the beginning of all my projects and bring it into most of my files. The stuff I develop is all highly graphical and elaborately designed websites for Movie Studios… Paramount, Fox, Universal ect…

As much as I’d like to follow nice clean patterns all the time I just find it impossible sometimes. Here’s what I keep track of with my Global:

XML Files (text, release dates, videos, photos, ect..)
Initial SWF’s (Main, Home)
– the above is contained in a BulkLoader –
Reference to BulkLoader
Reference to Main.swf

Then throughout my Flash project I simply call up the xml file needed through my Global.vars.BulkLoader reference. I also keep my SoundController in my Main.swf so alot of times I talk back and forth with the Main.swf to trigger sounds, mute all sounds, turn them on.

I just don’t see any real other way around certain things then keeping them Global across my project. I try to use my Main.swf as my Globally accesible control panel and keep one reference to my Main.swf in my Global Singleton so I can talk to it easily anywhere I need to. Which like I said could be SoundControllers, TextureLoaders, Global Site Pausers, Video Controllers that also react to SoundControllers.

In my case I just don’t think there’s a better way to control multiple swf’s and multiple things going on at once without the use of at least my one Global Singleton.

First off, it’s dangerous to cite wikipedia–take a look at their “explanation” of a Private Class. Second, I didn’t mean to sound insulting in differentiating a singleton from a Singleton for you—some people really don’t know.

In all of the examples you cite, you talk about the Singleton as a possible inclusion in those design patterns, but why? Because there’s only a single Facade class in a Facade design pattern does not make it a Singleton class. In fact, it behaves very differently from a Singleton. A Facade handles variation as an interface to a subsystem, while a Singleton handles variation as the sole instance of a class.

If you added a Singleton to an Abstract Factory, it’s like putting a wart on the face of a beauty queen. Why would anyone do it? As for State objects being Singletons, I just don’t agree. It’s hard to imagine something as dynamic as a State implementation being a Singleton. In fact it gives me the creeps….

In loggers I can see the purpose of a Singleton. But seeing a purpose does not mean it’s a good idea to add a possible global variable to your mix.

However, this post (Saint Singleton: Have We Martyred a Design Pattern Unfairly?) was meant to encourage discussion, and with so many bright people on our blog, I should have expected more than a shrug from our readers.

So get involved in our Golden Lunch Bucket Contest #4 and enter the Golden Lunch Bucket World Cup!

Thanks for hanging in there.

Kindest regards,
Bill

The thing about the Singleton Pattern according to standards is that is makes the Application not to follow a principal like a class having a single responsability.

Should a principle be a law ? does it mean i have to have just one responsability in a class

the Singleton Pattern definition says:
“Singleton is a class which permits itself to be instantiated only once. It…

* has a private or protected constructor with no parameters.
* has a single, global means of access via a static method.
* cannot be subclassed nor instantiated with the new operator.
* uses lazy instantiation.
”
”
Singleton can be used—in fact, is required—in many situations, for example:

* caches
* device drivers
* dialog boxes
* loggers
* thread pools

”

so is it really that bad to use a Singleton ?

furthermore i found an excellent entrie on the subject and yes it bashes the GOF Singleton Pattern but it also states that there are some places where the use of the Singleton should be made … at the top tier of your application and in loggers

http://tech.puredanger.com/2007/07/03/pattern-hate-singleton/

I believe that you’re mixing Singletons as a design pattern and singletons as a single class within a system or pattern. Just to help us communicate, the class is capitalized (Singleton), and the single class is not capitalized (singleton).

Nothing I’ve said or other critics of the Singleton have said applies to singletons. So while each state implementation in a State design pattern is a singleton; none are Singletons.

Good to hear from you and thanks for your comments,
Bill

Hierarchical State Machines and State Machine patterns use singletons ( states are singletons ), some aspect oriented design and separation of concern designs use singletons and aren’t that bad. What i want to say here is that singletons can and should be used if their use is appropriate, singletons are present in the Facade pattern and permit loose coupling. it all depends on the way you feel more confortable developing sometimes using a singleton is just great!