Single-file Deployment

My programming pet peeve of late is deployment. I don't think I can ever again go back to the days when, in order to install an application on a new machine, I had to:

• install or upgrade a complete programming language interpreter (typically, hundreds of files) and:
  • arrange for my required version not to conflict with the versions that are already installed
  • arrange for my application to run under the correct version of the interpreter (typically, modifying one or more #! lines or setting up one or more "associations")
• install or upgrade all the third-party libraries needed by my application (typically, dozens of files) and:
  • make sure my application finds them (and not other versions)
  • make sure the operating system can find shared libraries or DLL's (which may require root or administrator privileges or else extra hassle)
  • make sure that other applications don't find the new versions and break
• install my application (typically, dozens of files comprising executables and application-specific libraries) and:
  • make sure that this version of my application doesn't conflict with older versions already installed
  • arrange for my application to find its libraries (typically, modifying paths in some config file)

OCaml solves this problem in an old-fashioned way: it has a real compiler and linker that combine all your code and app-specific and third-party libraries into one single executable. If you choose the native-code compiler, your application won't require an OCaml interpreter to be installed on the target system, and if you choose static linking, you can remove dependencies on system libraries as well. You can deploy your application at any point along the continuum from completely self-contained (but bulky) to compact (but with external dependencies).

Honesty compels me to mention that Tcl, the first language that solved the deployment problem for me, goes one step further than OCaml. Tcl's Starkit technology, which allows me to package my application, all its app-specific and third-party libraries, and the complete Tcl interpreter into one single-file executable, also uses a Virtual File System (VFS) to allow me to package non-code files within the executable: this includes things like data files, documentation, images, etc, and it does it using very efficient memory-mapped technology. If this is possible with OCaml, let me know how to do it!