Subject: Re: Why no standard foreign language interface?
From: Erik Naggum <>
Date: 2000/02/10
Newsgroups: comp.lang.lisp
Message-ID: <>

* Robert Posey <>
| Because if the standard has a standard interface, I could move the LISP
| code to a new machine without change.

  no, you couldn't.  think again.  whether you can move your code without
  change depends vastly more on the code to which you interface than the
  code that describes the interface.

| In addition, commonly needed low level language routines could be reused
| as well.

  pardon me, but this is wishful thinking bordering on nonsense.  have you
  ever tried to port _any_ code between disparate machines and operating
  systems?  have you seen how much work it takes to make C code export a
  portable interface?

  what you need is a tool that can take C (or whatever) source code and
  automatically produce the foreign function interface glue code that your
  Common Lisp implementation needs.  why even _think_ about such a silly
  thing as writing all the foreign function interface definitions by hand?

  this cry for a standard foreign function interface stuff is just plain
  stupid.  it detracts from the real answer in a really big way, because
  people can be sooo content to sit on their fat asses and whimper about
  the standard being mean and cheap and not giving them what they sorely
  "need", while the real solution is waiting very patiently for somebody to
  just stop staring at the stupid non-solutions and whining and whimpering,
  and just freaking _do_ it.

  believe me, once you can figure out the braindamaged syntax of all these
  stupid infix languages with a plethora of static types and other junk
  enough to do the necessary steps of (1) writing wrapper code in that same
  language or in C that is more friendly to a Common Lisp interface, and
  (2) knowing enough to write foreign function interface code in Common
  Lisp, producing output that fits one of umpteen different foreign
  function interface definition "languages" for various Common Lisp
  implementations is _really_ trivial.