Io: a small programming language

  title={Io: a small programming language},
  author={Steve Dekorte},
  booktitle={Conference on Object-Oriented Programming Systems, Languages, and Applications},
  • Steve Dekorte
  • Published in
    Conference on Object-Oriented…
    16 October 2005
  • Computer Science
Io is small prototype-based programming language. The ideas in Io are mostly inspired by Smalltalk[1] (all values are objects), Self[2] (prototype-based), NewtonScript[3] (differential inheritance), Act1[4] (actors and futures for concurrency), LISP[5] (code is a runtime inspectable / modifiable tree) and Lua[6] (small, embeddable).Io offers a more flexible language with more scalable concurrency in a smaller, simpler package than traditional languages and is well suited for use as both… 

Towards JIT compilation for IO language

This work describes the approach to dynamic compilation of programs in IO, explores programs with multiple or alternating behaviors, and proposes multi-version speculative inlining with fine-grained invalidation.

Transparent proxies for java futures

This work has designed and implemented a simple framework for proxy programming that employs a static analysis based on qualifier inference, but with additional novelties, and has a variety of applications, including support for asynchronous method calls returning futures.

Concurrency Oriented Programming in Lua

A system that provides Erlang-style concurrency has been designed and implemented for the Lua programming language and will help further change the view on the way to achieve concurrency.

A Modern Objective-C Runtime

There are currently two Objective-C runtime libraries in widespread use, and I have done a little work on this and submitted a patch to allow prototype-based object orientation to be supported.

Sub-method structural and behavioral reflection

This work extends structural reflection to cover sub-method elements and presents how sub- method structural reflection supports unanticipated partial behavioral reflection, and adds the concept of context to represent meta-level execution and shows how this allows behavioral reflection to be applied even to system classes.

Towards an actor-based concurrent machine model

This position paper informally describes how three high-level languages supporting different concurrency models can be mapped onto the extended model, allowing for both true parallelism as well as lightweight concurrency primitives such as coroutines.

A study of superinstructions and dynamic mixin optimizations

This thesis considers the performance of the dynamic language implementation in the context when dynamic system updates such as dynamic mixin installation or removal are performed repeatedly and with high frequency and proposes two optimization techniques for the implementation of dynamic languages.

Sub-Method Reflection

Persephone is presented, an efficient implementation of a sub-method meta-object protocol (MOP) based on AST annotations and dual methods that reconcile AST expressiveness with bytecode execution.

Mutable objects in R

This paper looks at R in the context of three paradigms of object oriented programming: mutable versus immutable objects, generic-function versus message-passing methods, and class-based versus prototype-based inheritance.

Duck Futures: A Generative Approach to Transparent Futures

This paper proposes duck futures that use a generative approach and shows that duck futures are much more efficient compared to previous notions of transparent futures and finds that transparent futures, despite their limitations, can be very useful in practice.



Concurrent object-oriented programming

The actor model as a framework for concurrent systems1 and some concepts which are useful in building actor systems are discussed and some common patterns of concurrent problem solving are outlined.

Lua-An Extensible Extension Language

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.

Smalltalk-80: The Language and Its Implementation

This book is the first detailed account of the Smalltalk-80 system and is divided into four major parts: an overview of the concepts and syntax of the programming language, a specification of the system's functionality, and an example of the design and implementation of a moderate-size application.

Self: The power of simplicity

Because SELF does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures, and offers new insights into object-oriented computation.

Concurrent object-oriented programming in Act 1

A model of computation based on the notion of actors, active objects that communicate by message passing, which meets the requirements for organizing programs as societies.

Class-based NewtonScript Programming, PIE Developers magazine

  • Class-based NewtonScript Programming, PIE Developers magazine
  • 1994

LISP I programmer's manual

  • LISP I programmer's manual
  • 1960