Paradigm Prototype Object-oriented
Designed by Walter Smith
Developer Apple Computer
First appeared 1993 (1993)
Typing discipline Dynamic
Influenced by
Self, Dylan

NewtonScript is a prototype-based programming language created to write programs for the Newton platform.[1] It is heavily influenced by the Self programming language, but modified to be more suited to needs of mobile and embedded devices.[2]


On August 3, 1993, Apple unveiled Apple Newton MessagePad. The device had 640 KB RAM and 4 MB ROM, running on 20 MHz Acorn RISC machine.

The main intention behind Newton project, was to develop a device capable of replacing a computer while being portable.With limited battery and memory, the developers were looking for programming language capable of meeting these challenges.

The developers looked at C++ language but realized that it lacked flexibility. They started focusing on prototype based languages and were impressed with Smalltalk and Self.[3] Concurrently Apple was developing another dynamic programming language called Dylan, which was a strong candidate for Newton platform.[4]

However, both Self and Dylan were dropped out of consideration, as they were both in nascent stage for proper integration.

Instead, a team headed by Walter R Smith, developed a new language called as NewtonScript. it was influenced by dynamic language like Smalltalk and prototype model based like Self.[3]


Although NewtonScript was heavily influenced by Self, there were some differences in both the languages.

Differences aroused due to three perceived problems with Self.

  1. One is that the typical Self snapshot requires 32 MB of RAM to run in, whereas the Newton platform was designed to use only 128 KB for the operating system. This required some serious paring down of the engine to make it fit and still have room for applications.
  2. Another issue was performance. Since the language would be used for the entire system, as opposed to just running on an existing operating system, it needed to run as fast as possible.
  3. Finally, the inheritance system in the normal Self engine had a single parent object,[5] whereas GUIs typically have two — one for the objects and another for the GUI layout that is typically handled via the addition of a slot in some sort of GUI-hierarchy object (like View).

The syntax was also modified to allow a more text-based programming style, as opposed to Self's widespread use of a GUI environment for programming. This allowed Newton programs to be developed on a computer running the Toolkit, where the programs would be compiled and then downloaded to a Newton device for running.

One of the advantages of NewtonScript's prototype based inheritance was reduced memory usage, a key consideration in the 128 KB Newton. The prototype of a GUI object could actually be stored in ROM, so there was no need to copy default data or functions into working memory.

Unlike class based languages, where creation of an object involves memory being allocated to all of its attributes, NewtonScripts' use of prototype inheritance allowed it to allocated memory to few fields like _proto and _parent instead of creating whole new object. Here, _proto and _parent signifies whether the object is using prototype or parent inheritance.[6]

An example to illustrate above concept, a developer might create a new button instance. If the button uses the default font, accessing its font "slot" (i.e., property or member variable) will return a value that is actually stored in ROM; the button instance in RAM does not have a value in its own font slot, so the prototype inheritance chain is followed until a value is found. If the developer then changes the button's font, setting its font slot to a new value will override the prototype; this override value is stored in RAM. NewtonScript's "differential inheritance" therefore made efficient use of the Newton's expensive flash RAM by storing the bulk of the default data and code in the PDA's cheaper and much larger ROM.

Important terms

Views: They are objects created by Newton View System, which are created on run-time to render views.

Template: It is a blueprint from which views are created.

Protos: They can be blueprint for a template or a view, and are elements of NewtonScript code libraries.

Frame and Slot: Frame is a dynamic collection of slots, and one element of fram is called as a slot. A slot is made up of name and value. The value can be of any type. It is worthwhile to note that all objects in NewtonScript are frames.[7]

Soup and Entry: It is a related collection of frames/ data. Entry is an individual frame in a soup.

Frame Heap: RAM allocated dynamically by NewtonScript.

Base View: It is the main view of application, consisting of all the variables and methods used in the application.

Advantages and Disadvantages




With the cancellation of Newton project by Apple in 1998,[8] all further mainstream developments on NewtonScript were stopped. However, the features used in NewtonScript would continue to inspire other programming models and languages.

NewtonScript is also one of the conceptual ancestors (together with Smalltalk, Self, Act1, Lisp and Lua) of a general-purpose programming language called Io.[9]

The Io language implements the same differential inheritance model, which is used in NewtonScript to conserve memory.

The prototype-based object model of Self and NewtonScript was used in JavaScript, the most popular and visible language to use the concept so far.

See also


  1. Smith, W. R. (1994-02-01). "The Newton application architecture". Compcon Spring '94, Digest of Papers.: 156–161. doi:10.1109/CMPCON.1994.282931.
  2. 1 2 Schödl, Arno (2004-10-10). "The NewtonScript Programming Language". Retrieved 2016-09-15.
  3. 1 2 Smith, Walter R. (1995-01-01). "Using a Prototype-based Language for User Interface: The Newton Project's Experience". Proceedings of the Tenth Annual Conference on Object-oriented Programming Systems, Languages, and Applications. OOPSLA '95. New York, NY, USA: ACM: 61–72. doi:10.1145/217838.217844. ISBN 0897917030.
  4. "Dylan: An Object Oriented Dynamic Language". Retrieved 2016-09-22.
  5. Chambers, C.; Ungar, D.; Lee, E. (1989-01-01). "An Efficient Implementation of SELF a Dynamically-typed Object-oriented Language Based on Prototypes". Conference Proceedings on Object-oriented Programming Systems, Languages and Applications. OOPSLA '89. New York, NY, USA: ACM: 49–70. doi:10.1145/74877.74884. ISBN 0897913337.
  6. 1 2 "The NewtonScript Programming Language" (PDF). 1996. Retrieved 15 December 2016.
  7. McKeehan, Julie; Rhodes, Neil (1994). Programming for the Newton®: Software Development with NewtonscriptTM. 955 Massachusetts Avenue, Cambridge, MA 02139: AP Professional. ISBN 0-12-484800-1.
  8. "Apple cancels Newton". Retrieved 2016-09-22.
  9. "io guide". Retrieved 2016-09-15.
This article is issued from Wikipedia - version of the 11/24/2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.