Macromedia Director:


Director is an advanced environment for authoring multimedia applications. It offers two separate (though heavily integrated) ways to create an application. The first is by using Director's built-in visual development capabilities. Media (often referred to as sprites) can be dragged and dropped over a timeline (the score) and then they can have behaviors copied onto them from a library imparting interactivity. The second way (and this often requires the programmer to involve the first method above) is used when a more sophisticated form of interactivity/control is desired. It relies on the object-oriented language Lingo to script these behaviors and then control the program itself.

The goods (in no real order):

Animation: Director has a large suite of tools to create and tweak animations. It allows full control over positioning, color, "ink", "blend", tweening, keyframing, timing, the sprite itself, and basically anything else you could want to change over time. Sprites can be added/removed while the application is running (by the program), and changed dynamically in response to either user or program prompting. Many things can be happening at once and Director will keep chugging along.

Multimedia Support
: Director was built to integrate all types of media. The control it affords over sound and video includes the ability to control tempo and playback, cueing of certain events in the media to trigger an event in the program, or control of the media from within Director itself.

Networking/Internet: Director has functions to use many common internet protocols (ftp, http, and at a lower level, tcp). There are routines built-in to perform many operations on URLs, to retrieve files and text from the web, send email, and all sorts of other stuff. There are also provisions to allow multiple applications made in Director to talk to each other over a network and pass messages back and forth.

Lingo: This is the most powerful feature of Director. Lingo is a robust programming language. It's a relatively full language, allowing for most anything you want to do (you can mess around with memory, low-level drivers, etc). Almost anything that isn't built into Director can be created in Lingo.

Cross-platform Creation: If a program is designed from the start to be cross-platform, and care is taken to make sure nothing specific to the platform is used, creating a version to run on another OS is as simple as opening the source files on the target OS in Director and creating the application there. A quick example would involve setting the applications title bar, in Windows, the program makes a call to a Win-specific function that would not compile on the Mac. It's small stuff, but it can build up if the programmer isn't careful.

Database Support: Director can access a DB to retrieve/store information at runtime.

Debugger: To go along with Lingo, Director includes a decent debugger. It allows you to set breakpoints, watch variables, set variables during runtime, watch function calls, and a host of other things.

Extensibility: While Lingo can do many things, sometimes it can't do it all. For this, Director has an SDK (a software development kit) where you can write 'plugins' in another language, and then use them in Director. There are many of these freely available on the web, so it's often better to use something someone else did than to do it yourself.

Shockwave: After creating something in Director, it's simply a matter of clicking to create something deployable on the web. The application is greatly compressed, and will play over the web on any platform that has the plugin (it's available on MacOS, Windows 95/98/NT, and some versions of Unix).

The bads:

Little Built-in Interaction
: Doing almost any interaction in Director requires the programmer to dirty their hands slighty with Lingo. Even the built-in behaviors and scripts require a little bit of tinkering to get to work exactly right. While building a complex GUI is certainly an option in Director, doing so would require a slightly larger commitment than doing it in on one of the other packages.

Lingo: As is the case with any 'real' language, picking up Lingo takes a bit of getting used to. Its syntax is VERY verbose and it's sometimes a little fuzzy on what is the proper way to do something. Helpful error messages are almost non-existant. A real quick snippet of Lingo code to change one sprite to another (don't worry about what all this means, just take note of the language used to do it):
set the member of sprite the currentSpriteNum to member "newSprite"
Complexity: Director's interface is not the best in the world. There are a staggering number of windows, menus, and buttons that make up the interface. Sadly, most of them are not as intuitive as they could be. To do relatively simple things requires a decent amount of know-how. There are tons of menus and windows, and until familiarity is gained with the program, getting things done is often quite a chore.

Cross-platform Creation: If it's decided that a program needs to be cross-platform once the programming has begun and media been created, it can often be a large undertaking to rework the code to be compatible across different systems.

Collaboration: Again, if a project isn't thought out from the beginning, it will become very hard for different people to work on the same project at the same time. It's certainly doable, but only if attacked from the right angle.

Hardware Requirements: Director is a resource hog. RAM is a premium when creating and running, and a fast processor is good to have to run it at an acceptable rate. Another concern when using Director is that while authoring, lots of screen real estate is very nice in order to have many windows open.

Examples of when to use and not to use Director:

When to use:

The creation of a very flashy, media rich application. If things need to be happening simultaneously, such as text scrolling, the user typing at a prompt, and Director reacting to that typing all on the fly, Director is going to afford the easiest environment for this to take place.

When not to use:

If the programmer wanted a static, though highly navigated (as in many different scenes), program, such as a 'hypertext' system or perhaps a large volume of information that needs to be integrated, Director isn't the best choice.

to intro -or- to the 'other' tools

or bug jesse and ask him what's up.