You must be familiar with the ways to configure your development environment. Flex Software Development Kit (SDK) primarily provide XML files that you use to configure the settings. The flex-config.xml file defines the default compiler options for the compilers.

In addition to server and compiler configuration settings, you can also modify the messaging and data management settings, the JVM heap size, Adobe^® Flash^® Player settings, and logging and caching settings.

For more information about configuring your Flex SDK environment, see SDK configuration.

Flex includes application compilers and component compilers. You use the application compilers to compile SWF files from MXML and other source files. You use the component compilers to compile SWC files from component files. You can then use SWC files as dynamic or static libraries with your Flex applications.

The application compilers take the following forms:

• mxmlc command-line compiler. You launch the mxlmc compiler from the command line to create a SWF file that you then deploy to a website.

• fcsh compiler shell. Provides an optimized environment for using the mxmlc command-line compiler. For more information, see Using fcsh, the Flex compiler shell.

The component compilers take the following form:

• compc command-line compiler. You open the compc compiler from the command line to create SWC files. You can use these SWC files as static component libraries, themes, or runtime shared libraries (RSLs).

For information on using the compilers, see Flex compilers.

To test your applications, you run the application SWF files in a web browser or the stand-alone Flash Player. If you encounter errors in your applications, you can use the debugging tools to set and manage breakpoints in your code; control application execution by suspending, resuming, and terminating the application; step into and over the code statements; select critical variables to watch; evaluate watch expressions while the application is running; and so on.

Flex provides the following debugging tools:

The fdb command-line debugger

The fdb command-line debugger provides a command-line interface to the debugging experience. With fdb, you can step into code, add breakpoints, and check variables. For more information, see Command-line debugger.

AIR Debug Launcher (ADL)

ADL is a command line debugger for Adobe^® AIR™ applications.

You can log messages at several different points in a Flex application's life cycle. You can log messages when you compile the application, when you deploy it to a web application server, or when a client runs it. You can log messages on the server or on the client. These messages are useful for informational, diagnostic, and debugging activities.

Flex includes the following logging mechanisms that you use when working with Flex applications.

Client-side logging

When you use the debugger version of Flash Player or start your AIR application using AIR Debug Launcher, you can use the trace() global method to write out messages or configure a TraceTarget to customize log levels of applications for data services-based applications. For more information, see Client-side logging and debugging.

Compiler logging

When compiling your Flex applications from the command line, you can view deprecation and warning messages, and sources of fatal errors. For more information, see Compiler logging.

You can use any number of component classes in your Flex applications. These classes can be MXML or ActionScript files. You can use classes to extend existing components or define new ones.

Component classes can take the form of MXML, ActionScript files, or as SWC files. In MXML or ActionScript files, the components are not compiled but reside in a directory structure that is part of your compiler's source path. SWC files are described in SWC files.

Component libraries are not dynamically linked unless they are used in a Runtime Shared Library (RSL). Component classes are statically linked at compile time, which means that they must be in the compiler's source path. For information about creating and using custom component classes, see Custom Flex components.

A SWC file is an archive file for Flex components and other assets. SWC files contain a SWF file and a catalog.xml file. The SWF file inside the SWC file implements the compiled component or group of components and includes embedded resources as symbols. Flex applications extract the SWF file from a SWC file, and use the SWF file's contents when the application refers to resources in that SWC file. The catalog.xml file lists of the contents of the component package and its individual components.

You compile SWC files by using the component compiler, compc. SWC files can be component libraries, RSLs, theme files, and resource bundles.

To include a SWC file in your application at compile time, it must be located in the library path. For more information about SWC files, see About SWC files.

Other application assets include images, fonts, movies, and sound files. You can embed these assets at compile time or access them at run time.

When you embed an asset, you compile it into your application's SWF file. The advantage of embedding an asset is that it is included in the SWF file, and can be accessed faster than when the application has to load it from a remote location at run time. The disadvantage of embedding an asset is that your SWF file is larger than if you load the resource at run time.

The alternative to embedding an asset is to load the asset at run time. You can load an asset from the local file system in which the SWF file runs, or you can access a remote asset, typically though an HTTP request over a network.

Embedded assets load immediately, because they are already part of the Flex SWF file. However, they add to the size of your application and slow down the application initialization process. Embedded assets also require you to recompile your applications whenever your asset files change.

For more information, see Embedding assets.