Summary
Deployment is the work it takes to move from finished application to application working on the end-users desktop/server/other computer to keeping the application up to date.
See Also
- Distribution Mechanisms
- Tkwrap
- from the WinTclTk project
- Building Stand Alone Executables in Unix
- with mktclapp
- Building Stand-Alone Tcl/Tk Applications under Mac OS X
- VFS
- Critcl builds C extensions on-the-fly
- MicroTcl for Tcl9
- Jean-Claude Wippler
- James Garrison
- Script to merge C source files
- How can I compile Tcl type scripts into binary code
- COMPANY: Career Demon.com plc
- Cameron Laird's personal remarks on deployment
- Software Dock
- an interesting academic project in this area:
- A Poor Boy does Deployment
- the ravings (;-)) of Rohan Pall as he struggles to solve various deployment issues. This is a stream of conciousness description to show people that this stuff of putting an application on a desktop is non-trivial.
Issues to be considered
- On what platforms does the application need to run?
- Will the application and all of its dependencies run on these platforms?
- Where in the end-user's environment does the application and its components reside?
- How many of the application's dependant components do you need to deploy (your own tcl/tk interpreter? extensions, stand alone additional applications, images, fonts, drivers, libraries, etc.)?
- When a bug is encountered, how do you ensure that all end-users are updated appropriately?
- When end-users' versions of an application are updated, how to you ensure that data are properly updated?
- When end-users' versions of an application are updated, how to you ensure that they can revert to a prior version (when possible)?
- How can you determine how many end-users are using the application?
- Do the end-users need to share data, and if so, how do they do this?
- Are there any resource/locking issues with multiple accesses to the application or to the data (either multiple by one person, or multiple people accessing "simultaneously")?
- What permissions are required for the application to be installed - some systems require special permissions for registry updates, system wide directories to be updated, etc.?
- What special hardware needs must be met?
- What operating system / driver patches must be in place?
- In what format should the application and its components be shipped - Deployment file formats?
- How do you determine an accurate picture of important information by someone reporting a problem? For instance, what version of each component being used by the application, what platform, what patches, etc.?
The Wikipedia has a serious page [L1 ] on the topic.
Single-Executable Deployment
Various tools exist for creating single-executable deployments:
- Tclkit
- also see below
- cookit
- a standalone Tcl/Tk binary similar to Tclkit at http://www.endorser.org/cookit
- FreeWrap
- which works quite nicely
- prowrap
- a componen of TclPro
- Wize - Wish Integrated Zip Executable
- yet another deployment method, along with a development environment
- wrap
- the package that started it all
Some work that has been done on the concept of a starkit allows one to build a 2 part install - a one piece interpreter with a number of extensions built in, and one file per application, which contains its own database. This addresses some of the concerns from users regarding multiple stand alone documents reproducing all of the window manager support multiple times, using up a LOT more disk space.
Traditional Tcl installation
Bob Techentin wisely observes, "You might consider a 'traditional' tcl/tk installation, complete [with] additional packages, as a component of your application. Take a close look at how TclPro tools get installed, and you'll see that the 'wish' executable is actually a short shell script which sets some environment variables (e.g., LD_LIBRARY_PATH) and then execs the binary shell."
Building Scripts into Tcl
Simply compiling the scripts into a stand alone intepreter (adding the scripts as a series of character strings into a simple mainline that then feeds them into the interpreter) won't hide them or even speed things up that much. This is is a crude but simple mechanism, but gets the job done. VFS-based analaogues such as starpacks are likely preferable.
Tclkit
Another option is to use Tclkit's starkit [L2 ].
In a few steps:
- get Tclkit for your platform
- get the "SDX" scripted doc utility (platform independent) from [L3 ]
- create dirs "myapp.vfs/", "myapp.vfs/bin/", and "myapp.vfs/lib/"
- copy your main script to "myapp.vfs/bin/main.tcl"
- copy all packages you need as dirs inside "myapp.vfs/lib/"
- wrap it all up using "sdx fs2sd myapp" ("file system to scripted doc")
- that's it, you have a runnable "myapp"
- try it (double-click, or run "./myapp" on Unix)
JCW: There are ways to make "main.tcl" work in unpackaged as well as in packaged form, which is useful for debugging. All of this is based on Tcl's Virtual File System or VFS in short. All examples here [L4 ] and here [L5 ] use this same approach, you can unpack them (with "sdx sd2fs ...") to see how they work.
Jeff Godfrey: "[W]ith the advent of starkit/starpack technology, deployment issues are mostly a thing of the past ..."
Basekit
ActiveState's Tcl Dev Kit TclApp tool builds on starkit technology to make all the above a simple point-and-click exercise. It uses a file called basekit as its foundation.
Also be sure to check out the wondrous sample offerings at the Starkit Distribution Archive [L6 ]
Misc
LV: What would be a good web site for someone attempting to get a handle on these types of issues, in cases where a starkit is not an option?