Passing a Language through the Eye of a Needle

@article{Ierusalimschy2011PassingAL,
  title={Passing a Language through the Eye of a Needle},
  author={Roberto Ierusalimschy and Luiz Henrique de Figueiredo and Waldemar Celes Filho},
  journal={Queue},
  year={2011},
  volume={9},
  pages={20 - 29}
}
Scripting languages are an important element in the current landscape of programming languages. A key feature of a scripting language is its ability to integrate with a system language. This integration takes two main forms: extending and embedding. In the first form, you extend the scripting language with libraries and functions written in the system language and write your main program in the scripting language. In the second form, you embed the scripting language in a host program (written… Expand

Figures and Topics from this paper

Integrating lua into C for embedding lua interpreters in a C application
TLDR
This work proposes LuCa, a domain specific language for developing integrated applications of Lua and C, with C as the host language, and implements a LuCa processor as a translator from LuCa code into C code that calls appropriate C API functions. Expand
First-Class Functions in an Imperative World
TLDR
This paper presents some aspects of Lua that were designed with first-class functions in mind, in particular its module system, exception handling, iterators, facilities for object-oriented programming, and the API between C and Lua. Expand
On the Evolution of Programming Languages
TLDR
This paper suggests a set of experimental languages, which may rule the world of programming languages in the time of new multi-core architectures, to give supportive evidence that the new languages are more robust than the previous, and carry-over the mixed features of older languages. Expand
Scriptable operating systems with Lua
TLDR
The concept of scriptable operating system is proposed, which applies scripting development paradigm to the concept of extensible operating systems, and an implementation of a kernel-scripting environment that allows users to dynamically extend Linux and NetBSD operating systems using the scripting language Lua. Expand
Extending Linden Scripting Language on OpenSim
TLDR
It is verified that expanding OpenSim's domain-specific applications based on scripting technology is feasible and the correctness of the extended scheme is proved by the case study. Expand
Fast functional simulation with a dynamic language
  • C. Steele, J. Bonn
  • Computer Science
  • 2012 IEEE Conference on High Performance Extreme Computing
  • 2012
TLDR
A fresh approach to ISS is demonstrated that achieves performance comparable to a fast dynamic binary translator by exploiting recent advances in just-in-time (JIT) compilers for dynamic languages, such as JavaScript and Lua, together with a specific programming idiom inspired by pipelined processor design. Expand
ispc: A SPMD compiler for high-performance CPU programming
  • M. Pharr, W. Mark
  • Computer Science
  • 2012 Innovative Parallel Computing (InPar)
  • 2012
TLDR
A compiler, the Intel R® SPMD Program Compiler (ispc), is developed that delivers very high performance on CPUs thanks to effective use of both multiple processor cores and SIMD vector units. Expand
A stepwise approach to developing staged applications
TLDR
This paper proposes an extension to the staged model that decouples application design from specific execution environments, encouraging a stepwise approach for designing concurrent applications, similar to Foster’s PCAM methodology. Expand
A Flexible Approach to Staged Events
TLDR
The design of Leda is discussed, a platform that extends the staged model proposed by SEDA, decoupling application design from specific execution environments, and how its implementation in Lua helped to reinforce these design goals. Expand
Ebb: A DSL for Physical Simluation on CPUs and GPUs
TLDR
Ebb is presented, a Domain-Specific Language for simulation, that runs efficiently on both CPUs and GPUs, and is evaluated by comparing it to several widely used simulations, demonstrating comparable performance to handwritten GPU code where available, and surpassing existing CPU performance optimizations by up to 9 × when no GPU code exists. Expand
...
1
2
...

References

SHOWING 1-10 OF 20 REFERENCES
Scripting: Higher-Level Programming for the 21st Century
TLDR
This article explains why scripting languages will handle many of the programming tasks in the next century better than system programming languages. Expand
Extending and embedding the python interpreter
TLDR
This document describes how to write modules in C or C++ to extend the Python interpreter with new modules, which can define new functions but also new object types and their methods. Expand
Lua-An Extensible Extension Language
TLDR
Lua presents a mechanism offallbacks that allows programmers to extend the semantics of the language in some unconventional ways, as a noteworthy example, fallbacks allow the user to add different kinds of inheritance to the language. Expand
Revisiting coroutines
TLDR
This article introduces the concept of full asymmetric coroutines and provides a precise definition for it through an operational semantics, and demonstrates that full cor outines have an expressive power equivalent to one-shot continuations and one- shot delimited continuations. Expand
The evolution of Lua
We report on the birth and evolution of Lua and discuss how it moved from a simple configuration language to a versatile, widely used language that supports extensible semantics, anonymous functions,Expand
The Implementation of Lua 5.0
We discuss the main novelties of the implementation of Lua 5.0: its register- based virtual machine, the new algorithm for optimizing tables used as arrays, the implementation of closures, and theExpand
h., celes, W. the evolution of lua
  • In Proceedings of the 3rd ACM SIGPLAN Conference on History of Programming Languages (san Diego,
  • 2007
Python Software Foundation Extending and embedding the Python interpreter, release 2
  • Python Software Foundation Extending and embedding the Python interpreter, release 2
  • 2011
Ierusalimschy, r. revisiting coroutines
  • ACM Trans. Programming Languages and Systems
  • 2009
The engine survey: general results. Gamasutra
  • The engine survey: general results. Gamasutra
  • 2009
...
1
2
...