Having a good deployment toolchain is pivotal to the success of the programming language. It should be taken into account during language design if you plan that somebody is will be using that language for something. I think there are few ways by which language designer can help provide better deployment toolchain.
A proper, good deployment toolchain should provide following:
- It is possible to deploy any version of the program with a single click.
- There is an automatic mechanism that can update the programs before/while they run.
- Error reporting utilities that can communicate with development tools, and allow programmers to figure out what is happening when user runs the software.
- It is mostly safe for the user to download and run an arbitrary program.
- It is possible to single-click and run the program without a permanent install.
- Programs are portable along the platforms supported by the language. They should run, if the hardware can support them.
- If the author doesn't break a program intentionally, it won't break simply when time passes by.
- Should allow supplying the user manual along the program.
If you can't provide all of these easily, you have a broken deployment toolchain. It also means that the language designer failed to account for modern times. No exceptions to that. Although I'm unable to name any system that has the properties I described, I think this should be the goal. There's much less point in programming if nobody else but the designer can run the programs he created. There's no point in programming if the designer must fix his program once in a year because some fucktard breaks it every year.
Even if the deployment toolkit was complete, somebody would still write crappy software. But wouldn't it be nice to have a chance to write really good software with tools that support it? You'd have more time to squeal about broken OpenGL drivers or cheap broken poor hardware.
Installation and updating methods
There should be at least two deployment methods:
- HTTP URL into the package (HTTP -method of updating the software)
- Bittorrent Peer-to-peer transfer
A programmer must be able to easily provide new deployment methods if needed. It should be easy to share the programs, even without access to original deployment site. It should be possible to re-publish packages simply by copying them around. The initial deployment should provide a signature key, that makes it secure to update the software later.
Security and Reliability
It should be clear that the programs keep working even when the software updates around it, and it should be safe to run them. These are kind of things the software designer yearns on desktop side after writing web apps for a little while.
I believe it is achievable in a traditional, sandboxed dynamic language by dividing the standard modules into safe and unsafe. The unsafe modules are used for implementing the safe modules, and they're available for users to writing system software. The safe modules are there for every other kind of software, which the user can't entirely trust. Most user-programs would run in the safe mode. An attempt to access unsafe modules from the safe mode would produce an error.
The standard libraries in the language should extend to everything the operating system provides, and have strict backwards compatibility. Everything else should be supplied along the software package. It seems to be a good recipe for providing backwards compatibility.
I guess the capability system is a good way to provide additional safety, allowing the programs access system in limited way after getting privileges to do so. There could be several ways to ask for privileges.
Every software cannot possibly run on every client. There are systems with no displays, no users interacting with the system. Asking for privileges interactively there is waste of time.