Also, if you specify more details about what you are trying to do, you
will get more help.

HTH,

http://groups.google.com/group/comp.lang.lisp/msg/9afd12bc0906b4d7

to make sure things start up correctly (right user, etc.) and unattended
i use the `start-stop-daemon' program via a small script placed
in /etc/init.d/

`swank' (the server part of slime) and/or `screen' is also involved
sometimes

Probably your best shot is to translate it to JS and run it in Chrome.

Or buy ACL or LW and use their generate-application tools.

CLisp has one way, others others, increasingly uglierer.

• Xah's Emacs Lisp Tutorial
http://xahlee.org/emacs/elisp.html

for example, recently citing my own articles in newsgroup is becoming
a pain. I frequently need to turn a file path such as

file:///Users/xah/web/emacs/elisp.html

into the form

• Title
url scheme path

So, typically, i use web browser to find the article in question,
switch to emacs, paste the url scheme file path, press cursor moving
shortcuts and delete so that the part “file:///Users/xah/web/” becomes
“http://xahlee.org/”, then switch to browser again, copy the article
title, then switch back to emacs, type “• ” in the right location then
paste the title. Often, in a single post i needed to cite as many as 5
articles. And if i have to post few replies, this processing is
becoming a pain.

So, no longer content with the ways of the world, i resolved to have
lisp bear the brunt of the humar labor. Like this:

(defun xah-cite ()
        "Change the file path under cursor into title and path.

For example:
file:///Users/xah/web/emacs/apple_pc_kb_diff.html
becomes
• Difference Between Apple and PC keyboards
http://xahlee.org/emacs/apple_pc_kb_diff.html

The title came from HTML file's title tag.
This is Xah Lee's personal command assuming a particular dir
structure."
        (interactive)
        (let (bds ff title)
    (setq bds (bounds-of-thing-at-point 'filename))
    (setq ff (buffer-substring-no-properties (car bds) (cdr bds)))

    ;; if file path is url scheme, change it
    (when (string-match "^file://localhost/" ff)
      (setq ff (replace-regexp-in-string "^file://localhost/" "" ff))
      ) ;; Opera browser has the “localhost” shit
    (when (string-match "^file://" ff)
      (setq ff (replace-regexp-in-string "^file://" "" ff))
      )

    (setq title (get-html-file-title ff))

    (delete-region (car bds) (cdr bds))
    (insert "• " title "\n")
    (insert (replace-regexp-in-string "/Users/xah/web" "http://
xahlee.org" ff))
    ))

(defun get-html-file-title (fname)
"Return FNAME <title> tag's text."
 (let (x1 x2 linkText)
   (save-current-buffer
     (set-buffer (get-buffer-create " tmp8293"))
     (goto-char (point-min))
     (insert-file-contents fname nil nil nil t)

     (setq x1 (search-forward "<title>"))
     (search-forward "</title>")
     (setq x2 (search-backward "<"))
     (buffer-substring-no-properties x1 x2))))

So, now i put the cursor on the path, press a button, and there i show
the world the power of lisp!

  Xah
∑ http://xahlee.org/

You can deploy it as a binary (executable),
Or you can deploy it using the lisp environment as a run-time
environment (similar to java).
If you are using the lisp environment, your code will most likely
either be interpreted source, or byte-code(sort of an in-between of
source and full compilation).

There are advantages and disadvantages to each.

There are several typical ways, depending on:

1. The kind of app (interactive, "batch", or service daemon);

2. How widely it's going to be deployed (how many platforms);

3. What *kind* of platform (server or client/standalone);

4. Whether startup time is critical or not.

Some ways to package it include [*not* a complete list!]:

1. Single standalone executable: load all your FASLs into a Lisp,
   define a special-purpose top-level startup routine, and save
   the heap image ("core") and startup executable out as a single
   A.OUT, ELF, ".exe", ".dll", or whatever. You will have to build
   one of these for each separate target architecture the app needs
   to run on, and in some cases for each version of the OS.

2. Deliver a compressed source tarball [usually containing
   an ASDF or MK:DEFSYSTEM system definition file] and let the
   user unpack, compile, install, & run it. If you're somewhat
   careful, this can be fairly portable across machine architecture,
   operating system, and Common Lisp implementation.

Note: These two are not exclusive if the compilation process in #2
produces a standalone executable, as in #1. But #1 is really only
helpful for short-lived human-interactive apps. Any kind of "server"
(service daemon) application should *NOT* be run from scratch for
each service request, but rather should be run once per system boot,
as a persistent daemon which is "connected to" with some kind of
protocol [possibly with connection caching, depending on where the
requests are coming from]. In that mode, startup time is seldom
very important.

-Rob

If the program is for peer lisp programmers, the best way is to deploy
it as a tarball of lisp sources, or even better, to write an .asd file
and a cliki page with a  (:package ...) link so it can be
asdf-install'ed and asdf:load-op'ed.

Lisp programmers use a lisp REPL as shell (cf. http://clisp.cons.org/clash.html )
so they don't mind typing:

   (asdf:oos 'asdf:load-op :your-program) RET
   (your-program:main) RET

to run your-program.

If your lisp program is a web site for anybody, then you would
normally write a little script to copy it to the web server, and
launch the needed processes.

If your lisp program is a desktop application, or a command line tool,
then you may want to generate a single binary executable.  Each lisp
implementation provide its own specific function to generate such an
executable. (cf. eg.  http://clisp.cons.org/impnotes/image.html ).

And so on.

Let me see if I can summarize what I think you are all telling me.