cgi-bin and interpreter startup time

Motivated by generating an intuition for the bare minimum time a cgi-bin script request could take, I've generated an unprincipled list of startup times for various interpreters.

There are lots of reasons to find this metric useless. It's nothing like a measure of how fast code can run in the interpreter (arithmetic, regexp matching, etc), or even the time needed to load in common dependencies.

Eye-balling start up times for what I have installed on my system, there are 3 groups.

• fast (<.005s): perl, awk, sed, bash, lisp(!)
• okay: php, bb, py, node, ruby
• slow (>1s): julia, lisp, R, clojure

    # hi in various interpreters 
    hi_lisp(){ sbcl --no-sysinit --no-userinit --eval '(progn (format t "hi!") (quit))';}
    # loads quicklisp
    hi_lpslow(){ sbcl --eval '(progn (format t "hi!") (quit))';}
    hi_pl(){ perl -E "say 'hi'";}
    hi_py(){ python -c "print('hi')";}
    hi_node(){ node -e "console.log('hi')";}
    hi_ruby(){ ruby -e "puts 'hi'";}
    hi_bb(){ bb '(print "hi\n")'; }
    hi_bash() { bash -c "echo hi";}
    hi_php() { php -r 'echo "hi\n";';}
    hi_r() { Rscript --vanilla -e "print('hi')";}
    hi_jl() { julia -e 'print("hi")';}
    hi_clj() { clj --eval '(println "hi")';}
    hi_apl() { echo -e '"hi"\n)OFF' |  apl --noCIN -q --noSV; }
    hi_awk() { echo hi | awk '{print $0}';}
    hi_sed() { echo hi | sed -n p;}

    # time it. find all hi* functions. export them so hyperfine can see 'em
    csvtime() { hyperfine $1 --style none --export-csv >(cat) 2>/dev/null ; }
    for f in $(typeset -F|grep -oP 'hi_[a-z]+$'); do
      export -f $f
      csvtime $f;
    done |
  sort -u | # remove repeated headers. "command" sorted before "hi*" => header on top
  perl -F, -slane 'print join "\t", map {$_=/^[0-9]/?sprintf("%.5f",$_):$_} @F'| # fewer sigfig for numbers
  awk 'NR<2{print $0;next}{print $0|"sort -k2,2"}'| # sort all but the header
  sed s/hi_// # remove function name that helped identify in $(typeset -F)

Musings in https://eccentric-j.com/blog/clojure-like-its-php.html consider babashka's faster-than-clojure start up time in context of cgi-bin scripts. Aside: compiling clojure with GraalVM and serving quick starting binaries is an essential part of a work project.

I find the babashka write-up compelling, but not for the same reason as the author. I have a very small collection of local cgi-bin scripts, all in bash. And all are under the magic 100-or-so lines that mark when convention says use a "real programming language."

 echo -e "file\tline-count\ttype"
 ssh s2 '
  for f in /srv/http/cgi-bin/*; do
   echo -e "$(basename $f)\t$(wc -l < $f)\t$(file -bL $f|sed s/,.*//)";
  done'

These utilities emerged organically from small itches and lean heavily on other bigger tools (calibre, sqlite, filesystem). Shell's a good fit, but the choice wasn't deliberate. It's nice to be prompted to think about it. The procrastinator-looking-for-an-escape is always interested in exploring other hacks.

I'd previously been burned by noticeably slow python. Matplotlib generated an image of the week's soccer roster to embed in emails for up-to-date whos-going-to-show-up status. It was slow enough that opening the google sheet in a new tab was often competitive time-wise. (Were I to redo the project, I'd use shell and imagemagick)

To that end, I'm curious what the quickest start up is for common interpreters are.