FAQ
Hi all,

there appears to be plenty of projects implementing various interpreters;
golang, lua, javascript etc. However, most, if not all, appear to be in a
very immature state.

I am looking for a package which, in pure go, can execute code dynamically
(actually dont care which language), in a manner similar to lua. I intend
on building a plugin system for one of my programs; hence the interpreter
must be reasonably mature/resilient against syntatical or semantic errors
in the input.

At the moment, 'otto' seems aligned with my needs:
https://github.com/robertkrimen/otto

However I am not sure if it is resilient enough against script errors, so
its pending consideration depending on my own experimenting and any advice
you can provide (if you have used otto).


Can anyone provide insight/reccomendations regarding this choice? I just
need a package which can form the basis of a simple plugin system.

Thanks in advance,

Tommy <3


PS: C-bindings or other solutions which require additional compilation
steps are out of the question; considering the nature of my project.

--
You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

Search Discussions

  • Sebastien Binet at Jul 19, 2013 at 8:21 pm

    On Fri, Jul 19, 2013 at 7:13 AM, Tom D wrote:
    Hi all,

    there appears to be plenty of projects implementing various interpreters;
    golang, lua, javascript etc. However, most, if not all, appear to be in a
    very immature state.

    I am looking for a package which, in pure go, can execute code dynamically
    (actually dont care which language), in a manner similar to lua. I intend on
    building a plugin system for one of my programs; hence the interpreter must
    be reasonably mature/resilient against syntatical or semantic errors in the
    input.

    At the moment, 'otto' seems aligned with my needs:
    https://github.com/robertkrimen/otto

    However I am not sure if it is resilient enough against script errors, so
    its pending consideration depending on my own experimenting and any advice
    you can provide (if you have used otto).
    a nice go-based VM, (and perhaps even a package to build VMs like PyPy
    ?) would indeed be a nice, if somewhat huge, project :)

    Can anyone provide insight/reccomendations regarding this choice? I just
    need a package which can form the basis of a simple plugin system.
    depending on what you want to do (is it scripting your
    library/application ? or extending it ?) you could perhaps just rely
    on external processes, or a go9p rpc-based setup:
    https://groups.google.com/forum/#!topic/golang-nuts/BRIl04cVdQA

    -s

    --
    You received this message because you are subscribed to the Google Groups "golang-nuts" group.
    To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts+unsubscribe@googlegroups.com.
    For more options, visit https://groups.google.com/groups/opt_out.
  • Tim Jurcka at Jul 19, 2013 at 8:24 pm
    Hey,
    On 7/19/13 7:13 AM, Tom D wrote:
    Hi all,

    there appears to be plenty of projects implementing various interpreters;
    golang, lua, javascript etc. However, most, if not all, appear to be in a
    very immature state.

    I am looking for a package which, in pure go, can execute code dynamically
    (actually dont care which language), in a manner similar to lua. I intend
    on building a plugin system for one of my programs; hence the interpreter
    must be reasonably mature/resilient against syntatical or semantic errors
    in the input.

    At the moment, 'otto' seems aligned with my needs:
    https://github.com/robertkrimen/otto

    However I am not sure if it is resilient enough against script errors, so
    its pending consideration depending on my own experimenting and any advice
    you can provide (if you have used otto).
    Otto is pretty much, as mentioned in README, a hybrid ECMA3/ECMA5
    interpreter. Parts of the specification are still works in progress.
    Don't expect it to run your Node.js (or whatever [platform]) apps. but
    it will run (most) valid JavaScript code you can throw at it as
    expected/described by ECMA-262. If not,
    https://github.com/robertkrimen/otto/issues/new
    Can anyone provide insight/reccomendations regarding this choice? I just
    need a package which can form the basis of a simple plugin system.
    Depending of your definition of "simple", Otto is not a bad choice. ;)
    Thanks in advance,

    Tommy <3


    PS: C-bindings or other solutions which require additional compilation
    steps are out of the question; considering the nature of my project.
    --
    You received this message because you are subscribed to the Google Groups "golang-nuts" group.
    To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts+unsubscribe@googlegroups.com.
    For more options, visit https://groups.google.com/groups/opt_out.
  • Tom D at Jul 20, 2013 at 11:13 am
    Yes, thats fine. Now the last concern I have is wether it will handle
    poorly/incorrectly written scripts gracefully. What do you think?

    I think in Go its not possible to cause a segfault without the unsafe
    package, so I don't have to worry about arbitrary code execution.


    On Saturday, 20 July 2013 05:17:47 UTC+10, Tim Jurcka wrote:

    Hey,
    On 7/19/13 7:13 AM, Tom D wrote:
    Hi all,

    there appears to be plenty of projects implementing various
    interpreters;
    golang, lua, javascript etc. However, most, if not all, appear to be in a
    very immature state.

    I am looking for a package which, in pure go, can execute code
    dynamically
    (actually dont care which language), in a manner similar to lua. I intend
    on building a plugin system for one of my programs; hence the
    interpreter
    must be reasonably mature/resilient against syntatical or semantic errors
    in the input.

    At the moment, 'otto' seems aligned with my needs:
    https://github.com/robertkrimen/otto

    However I am not sure if it is resilient enough against script errors, so
    its pending consideration depending on my own experimenting and any advice
    you can provide (if you have used otto).
    Otto is pretty much, as mentioned in README, a hybrid ECMA3/ECMA5
    interpreter. Parts of the specification are still works in progress.
    Don't expect it to run your Node.js (or whatever [platform]) apps. but
    it will run (most) valid JavaScript code you can throw at it as
    expected/described by ECMA-262. If not,
    https://github.com/robertkrimen/otto/issues/new
    Can anyone provide insight/reccomendations regarding this choice? I just
    need a package which can form the basis of a simple plugin system.
    Depending of your definition of "simple", Otto is not a bad choice. ;)
    Thanks in advance,

    Tommy <3


    PS: C-bindings or other solutions which require additional compilation
    steps are out of the question; considering the nature of my project.
    --
    You received this message because you are subscribed to the Google Groups "golang-nuts" group.
    To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts+unsubscribe@googlegroups.com.
    For more options, visit https://groups.google.com/groups/opt_out.
  • Travis Simon at Jul 20, 2013 at 3:51 am
    You might also check this thread:
    https://groups.google.com/forum/#!topic/golang-nuts/ZrKAGbatyYY
    On Friday, 19 July 2013 15:13:02 UTC+10, Tom D wrote:

    Hi all,

    there appears to be plenty of projects implementing various interpreters;
    golang, lua, javascript etc. However, most, if not all, appear to be in a
    very immature state.

    I am looking for a package which, in pure go, can execute code dynamically
    (actually dont care which language), in a manner similar to lua. I intend
    on building a plugin system for one of my programs; hence the interpreter
    must be reasonably mature/resilient against syntatical or semantic errors
    in the input.

    At the moment, 'otto' seems aligned with my needs:
    https://github.com/robertkrimen/otto

    However I am not sure if it is resilient enough against script errors, so
    its pending consideration depending on my own experimenting and any advice
    you can provide (if you have used otto).


    Can anyone provide insight/reccomendations regarding this choice? I just
    need a package which can form the basis of a simple plugin system.

    Thanks in advance,

    Tommy <3


    PS: C-bindings or other solutions which require additional compilation
    steps are out of the question; considering the nature of my project.
    --
    You received this message because you are subscribed to the Google Groups "golang-nuts" group.
    To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts+unsubscribe@googlegroups.com.
    For more options, visit https://groups.google.com/groups/opt_out.
  • Travis Simon at Jul 20, 2013 at 3:52 am
    You might also check this thread:
    https://groups.google.com/forum/#!topic/golang-nuts/ZrKAGbatyYY

    --
    You received this message because you are subscribed to the Google Groups "golang-nuts" group.
    To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts+unsubscribe@googlegroups.com.
    For more options, visit https://groups.google.com/groups/opt_out.

Related Discussions

Discussion Navigation
viewthread | post
Discussion Overview
groupgolang-nuts @
categoriesgo
postedJul 19, '13 at 5:56a
activeJul 20, '13 at 11:13a
posts6
users4
websitegolang.org

People

Translate

site design / logo © 2022 Grokbase