9

Some languages like Python, Lua, and Tcl are designed with the intention that you can easily embed the interpreter into some other native program. For example, many VFX applications like Nuke, Maya, and Houdini have an embedded Python script editor that executes the Python scripts in-process so they can manipulate the host application. Lua is popular as a language embedded in some games.

What was the first such scripting language that was specifically intended to be hosted inside of some other large host process, rather than just being invoked externally by shelling out the way you might execute a typical Bash or Perl script?

Later edit: LISP was mentioned in the comments, but not specifically as an answer. I have accepted the Forth answer as being a really interesting language that wound up in all sorts of interesting places, was quite early, and met all the requirements of what I was looking for. That said, it seems LISP definitely at least deserves the "honorable mention" that it got in the comments, and pre-dates forth quite a bit.

Improve this question
  • 2
    Tough to answer this without adding some qualifiers, since any script interpreter can trivially be built as a library callable from some other native/compiled language. I think Python was the first to do it WELL, since it has an API that also supports native extensions WHILE embedding it. – Brian H Nov 3 '18 at 22:57
  • 3
    An often overlooked one is Microsofts VBA (as well as VBS) developed in the early 1990s. – Raffzahn Nov 4 '18 at 0:09
  • 1
    Excel's formulas are a kind of embedded "language", but I doubt that's the kind of answer you are looking for. If you revise your question, consider that. – DrSheldon Nov 4 '18 at 2:39
  • 4
    An honourable mention should be made for a variety of LISPs that were used for scripting purposes in many applications, e.g. Emacs and AutoCAD. While the original language wasn't designed for embedding specifically (the concept didn't really exist when LISP was designed!), it is particularly well adapted for it because of how simple it is to implement (cf Greenspun's 10th Rule). LISPs have continued to be used successfully even after purpose-designed alternatives became available (e.g. GIMP, which is scripted using a variant of Scheme). – Jules Nov 4 '18 at 3:00
  • 4
    Can you clarify what it is specifically that you are looking for? In the beginning, you ask about languages, but the properties you list are mostly about language implementations, which is a completely different thing. For example, the Ruby language wasn't designed with embedding in mind, but the MRuby, Rubinius, JRuby, and IronRuby implementation were specifically designed with embedding in mind. So, are you asking about languages (and what are the properties of a language that you consider important for embedding) or implementations? – Jörg W Mittag Nov 4 '18 at 9:46
16

Probably Forth. Forth was initally a stack of Fortran punch cards Chuck Moore would carry around with him in the late 60s to simplify his programming jobs, which eventually evolved into it's own language (or a native implementation). However a Forth is so simple it can be implemented in practically any language, and so powerful it is worth doing. The popularity is currently at what I would assume to be an all-time low, but it's picking up again. In the 70s and 80s you could get a Forth for pretty much any system and embed one in any application.

Improve this answer
  • OpenFirmware machines provide a Forth shell; as a result you could technically program Forth on a Mac without installing an OS as recently as 2006. – Tommy Mar 20 '19 at 13:57
12

REXX is a scripting language designed in the late 70s/early 80s, and which has frequently been used in embedded applications. Its design goals are very similar to TCL and Python's -- to provide an easily extensible language that can be used to integrate functions provided by a variety of third-party software easily. That it is also easy to embed in that third-party software is essentially a by-product of that decision (as it is in Python's case too, although TCL did specifically intend that outcome in its design).

REXX's most popular incarnation was almost certainly ARexx, the standard scripting language of the Amiga OS, and which was first released the year before work began on TCL.

Improve this answer
  • 1
    One reason ARexx was so beloved on the Amiga was that it perfectly augmented the pre-existing interprocess communication (IPC) provided by Amiga's Exec ("multitasking executive"). Many programs had already built in access to the IPC, and with ARexx added, different programs could easily be set to work together in ways their authors had not imagined. – RichF Nov 4 '18 at 5:58
  • 1
    This doesn't seem technically correct. The question didn't ask about "embedded applications". Rather, embedding the scripting interpreter within an application. AFAIK, Rexx is designed as a macro language that can script compatible apps, but Rexx is not embedded in those apps. Tcl and Python are designed to be embedded in apps. – Brian H Nov 4 '18 at 13:42
  • Yes, we should be talking about "app program on the outside". For cases where a language is designed to allow orchestration of a single program (script runs program) then I'd nominate the command language for GEORGE 3 (ICL 1900 series machines, late 1960s) where a running program could interact with the script running it (a "macro") in quite complicated ways. – another-dave Nov 4 '18 at 16:08
7

TCL was invented in the late 1980s explicitly as an embedded command language. Its author, John Ousterhout, claims embeddability as a 'unique aspect' (at the time).

http://www.tcl.tk/about/history.html

Improve this answer
  • 4
    TCL was my first thought, too. Even after Python and Lua became available in the early-mid 90s, TCL was often the go-to language for applications that needed an embedded scripting language. For example, a lot of the big commercial electronic design application suites are scripted with TCL (e.g. Altera Quartus or Xilinx ISE). – Jules Nov 4 '18 at 2:48
0

I misread the question, so this is answering something different -- unless you consider that every language is embedded in machine language (aka the Instruction Set Architecture) of the particular processor.

..............

Any programming language from the 50's, 60's, or even 70's was, by today's standards, an embedded language for a tiny computer.

From my experience, although there are several other answers, I would propose Fortran.

One of my first computers was an IBM 360/30E, with a hard drive and tapes. The IBM System 360 was ubiquitous for business applications. The 360 model 30 was an 8-bit implementation of the instruction set. The E suffix indicated that it was equipped with a central memory store of 32,786 bytes. It ran IBM's DOS (Disk Operating System). I programmed it in Fortran 4.

I've seen an IBM model 1130 used for real-time control a gas chromatograph/mass spectrometer. By most standards, it was an embedded computer. Probably programmed in assembly language and Fortran.

I used a Data General Eclipse S-130 to monitor a plastics injection molding factory. There was a distributed dry-contact switch matrix that was probed and sampled by the S-130. It updated color screens throughout the factory. It was mostly programmed in Fortran, with a bit of assembly code for time-critical device drivers.

Improve this answer
  • Unless I totally misunderstand either your answer or the original question (and the other answers), I think we're talking about two very different meanings of embedded. You are referring to what "embedded computers", which is what has been morphing into "the internet of things" (when networked). As I understand the original question and the other answers, they are referring to embedding one language inside another: Forth inside Fortran, – manassehkatz-Moving 2 Codidact Mar 20 '19 at 19:18
  • 1
    I think you are correct. I misread the question. So it might mean Planner embedded inside Lisp? – cmm Mar 20 '19 at 19:41
  • Yes one language inside another – manassehkatz-Moving 2 Codidact Mar 20 '19 at 19:45
  • In the sense of TCL, it's not a language inside a language; it's a language inside a program. The idea is that you're writing a program to do "something", and as well as the something-specific commands, you'd like a programmable framework; and that is what TCL is for. The same sort of thing applies to mock-LISP in the emacs editor, for example. – another-dave Mar 20 '19 at 22:04
  • So, TECO is an example. A program, TECO, implementing a text processing language, TECO script in Q registers. And, before the great re-write, EMACS was a second-order example, being written in the TECO scriot language. – cmm Mar 21 '19 at 0:12

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.