First language designed to support embedding?
up vote
6
down vote
favorite
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?
programming
New contributor
|
show 7 more comments
up vote
6
down vote
favorite
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?
programming
New contributor
1
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 at 22:57
2
An often overlooked one is Microsofts VBA (as well as VBS) developed in the early 1990s.
– Raffzahn
Nov 4 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.
– Dr Sheldon
Nov 4 at 2:39
2
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 at 3:00
3
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 at 9:46
|
show 7 more comments
up vote
6
down vote
favorite
up vote
6
down vote
favorite
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?
programming
New contributor
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?
programming
programming
New contributor
New contributor
New contributor
asked Nov 3 at 21:09
wrosecrans
1343
1343
New contributor
New contributor
1
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 at 22:57
2
An often overlooked one is Microsofts VBA (as well as VBS) developed in the early 1990s.
– Raffzahn
Nov 4 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.
– Dr Sheldon
Nov 4 at 2:39
2
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 at 3:00
3
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 at 9:46
|
show 7 more comments
1
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 at 22:57
2
An often overlooked one is Microsofts VBA (as well as VBS) developed in the early 1990s.
– Raffzahn
Nov 4 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.
– Dr Sheldon
Nov 4 at 2:39
2
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 at 3:00
3
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 at 9:46
1
1
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 at 22:57
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 at 22:57
2
2
An often overlooked one is Microsofts VBA (as well as VBS) developed in the early 1990s.
– Raffzahn
Nov 4 at 0:09
An often overlooked one is Microsofts VBA (as well as VBS) developed in the early 1990s.
– Raffzahn
Nov 4 at 0:09
1
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.
– Dr Sheldon
Nov 4 at 2:39
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.
– Dr Sheldon
Nov 4 at 2:39
2
2
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 at 3:00
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 at 3:00
3
3
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 at 9:46
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 at 9:46
|
show 7 more comments
3 Answers
3
active
oldest
votes
up vote
11
down vote
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.
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 at 5:58
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 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.
– dave
Nov 4 at 16:08
add a comment |
up vote
6
down vote
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
2
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 at 2:48
add a comment |
up vote
3
down vote
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.
New contributor
add a comment |
3 Answers
3
active
oldest
votes
3 Answers
3
active
oldest
votes
active
oldest
votes
active
oldest
votes
up vote
11
down vote
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.
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 at 5:58
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 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.
– dave
Nov 4 at 16:08
add a comment |
up vote
11
down vote
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.
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 at 5:58
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 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.
– dave
Nov 4 at 16:08
add a comment |
up vote
11
down vote
up vote
11
down vote
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.
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.
answered Nov 4 at 3:20
Jules
8,61222246
8,61222246
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 at 5:58
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 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.
– dave
Nov 4 at 16:08
add a comment |
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 at 5:58
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 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.
– dave
Nov 4 at 16:08
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 at 5:58
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 at 5:58
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 at 13:42
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 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.
– dave
Nov 4 at 16:08
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.
– dave
Nov 4 at 16:08
add a comment |
up vote
6
down vote
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
2
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 at 2:48
add a comment |
up vote
6
down vote
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
2
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 at 2:48
add a comment |
up vote
6
down vote
up vote
6
down vote
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
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
answered Nov 4 at 2:30
dave
2041
2041
2
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 at 2:48
add a comment |
2
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 at 2:48
2
2
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 at 2:48
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 at 2:48
add a comment |
up vote
3
down vote
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.
New contributor
add a comment |
up vote
3
down vote
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.
New contributor
add a comment |
up vote
3
down vote
up vote
3
down vote
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.
New contributor
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.
New contributor
New contributor
answered Nov 4 at 14:16
dch
312
312
New contributor
New contributor
add a comment |
add a comment |
wrosecrans is a new contributor. Be nice, and check out our Code of Conduct.
wrosecrans is a new contributor. Be nice, and check out our Code of Conduct.
wrosecrans is a new contributor. Be nice, and check out our Code of Conduct.
wrosecrans is a new contributor. Be nice, and check out our Code of Conduct.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fretrocomputing.stackexchange.com%2fquestions%2f8146%2ffirst-language-designed-to-support-embedding%23new-answer', 'question_page');
}
);
Post as a guest
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
1
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 at 22:57
2
An often overlooked one is Microsofts VBA (as well as VBS) developed in the early 1990s.
– Raffzahn
Nov 4 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.
– Dr Sheldon
Nov 4 at 2:39
2
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 at 3:00
3
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 at 9:46