The Sourcemint JavaScript Loader provides a minimal CommonJS environment that requests optimized static JavaScript code files
called Bundles from a server via GET requests and boots these into sandboxes in the browser identified by the requested URL.

Applications may be coded directly in the bundle format. Alternatively the bundle format may be treated as a compile target.
The following tools can generate Sourcemint JavaScript Loader compatible bundles:

When testing an application use the ./loader.js file to get all error messages.

When deploying an application us the ./loader.min.gz file for optimum performance.

When using a different loader during development make sure only supported API features
of this loader are used. Load extra features along with your application by
augmenting a sandbox.

When writing or generating bundles make sure one consistent set of statically linked modules
is contained in each bundle file. Dynamic links to other modules or bundles must be made via
require.async() or require.sandbox() respectively. The hierarchy of how your application nests
these dynamic links will determine which modules must be included in subsequently loaded bundles
to avoid sending the same modules twice.

A module can only be memoized once for each Canonical Identifier (comprising of SandboxIdentifier/PackageIdentifier/ModuleIdentifier).
When placing modules into bundles make sure bundle filenames do not overlap with module filenames (and the reverse) as these
have the potential to conflict (modules and bundles share the same logical file hierarchy). The idea is that a set of statically
linked modules can always be combined into one file which is placed into the file that first requires the dependencies
and represents the entry point into the bundle.

Because loader plugins that are invoked by modifying the string literal passed to require() are not necessary
and combine two concepts that should really be separate and implemented differently. For more information see
this discussion.

The AMD Specification is a small subset combining several CommonJS Concepts in a different form.

CommonJS represents a more pure and modular approach to devising arbitrary JavaScript application architectures by
carefully layering a few core concepts into a framework that provides one small existential foundation
for all other concepts. It allows for isolated namespaces, nested package dependency structures and runtime sandboxes
as well as automatic conversion from source trees to optimized bundles. This loader is one existential foundation implementation
and fully compatible with the CommonJS Concepts.

In contrast RequireJS + almond focuses on optimally loading (primarily into the browser) a list of packages containing
JavaScript modules and resource files into a single namespace. In optimized form (for almond), several
key RequireJS features are not supported.