Factor (programming language)

Factor
Paradigm multi-paradigm: functional, concatenative, stack-oriented
Developer Slava Pestov
First appeared 2003
Stable release
0.97 / November 2, 2014 (2014-11-02)
Typing discipline strong, dynamic
OS Windows, macOS, Linux, others
License BSD license
Website factorcode.org
Influenced by
Joy, Forth, Lisp, Self
Influenced
Cat,[1] Concat[2]

Factor is a stack-oriented programming language created by Slava Pestov. Factor is dynamically typed and has automatic memory management, as well as powerful metaprogramming features. The language has a single implementation featuring a self-hosted optimizing compiler and an interactive development environment. The Factor distribution includes a large standard library.

History

Slava Pestov created Factor in 2003 as a scripting language for a video game.[3] The initial implementation, now referred to as JFactor, was implemented in Java and ran on the Java Virtual Machine. Though the early language resembled modern Factor superficially in terms of syntax, the modern language is very different in practical terms and the current implementation is much faster.

The language has changed significantly over time. Originally, Factor programs centered on manipulating Java objects with Java's reflection capabilities. From the beginning, the design philosophy has been to modify the language to suit programs written in it. As the Factor implementation and standard libraries grew more detailed, the need for certain language features became clear, and they were added. JFactor did not have an object system where you could define your own classes, and early versions of native Factor were the same; the language was similar to Scheme in this way. Today, the object system is a central part of Factor. Other important language features such as tuple classes, combinator inlining, macros, user-defined parsing words and the modern vocabulary system were only added in a piecemeal fashion as their utility became clear.

The foreign function interface was present from very early versions to Factor, and an analogous system existed in JFactor. This was chosen over creating a plugin to the C part of the implementation for each external library that Factor should communicate with, and has the benefit of being more declarative, faster to compile and easier to write.

The Java implementation initially consisted of just an interpreter, but a compiler to Java bytecode was later added. This compiler only worked on certain procedures. The Java version of Factor was replaced by a version written in C and Factor. Initially, this consisted of just an interpreter, but the interpreter was replaced by two compilers, used in different situations. Over time, the Factor implementation has grown significantly faster.[4]

Programming paradigm

Factor is a dynamically typed, functional and object-oriented programming language. Code is structured around small procedures, called words. In typical code, these are 1-3 lines long, and a procedure more than 7 lines long is very rare. Something that would idiomatically be expressed with one procedure in another programming language would be written as several words in Factor.[5]

Each word takes a fixed number of arguments and has a fixed number of return values. Arguments to words are passed on a data stack, using reverse Polish notation. The stack is used just to organize calls to words, and not as a datastructure. The stack in Factor is used in a similar way to the stack in Forth; for this, they are both considered stack languages. For example, below is a snippet of code that prints out "hello world" to the current output stream:

"hello world" print

print is a word in the io vocabulary that takes a string from the stack and returns nothing. It prints the string to the current output stream (by default, the terminal or the graphical listener).[5]

Not all data has to be passed around only with the stack. Lexically scoped local variables let you store and access temporaries used within a procedure. Dynamically scoped variables are used to pass things between procedure calls without using the stack. For example, the current input and output streams are stored in dynamically scoped variables.[5]

Factor emphasizes flexibility and the ability to extend the language.[5] There is a system for macros, as well as for arbitrary extension of Factor syntax. Factor's syntax is often extended to allow for new types of word definitions and new types of literals for data structures. It is also used in the XML library to provide literal syntax for generating XML. For example, the following word takes a string and produces an XML document object which is an HTML document emphasizing the string:

 : make-html ( string -- xml )
    dup
    <XML
        <html>
            <head><title><-></title></head>
            <body><h1><-></h1></body>
        </html>
    XML> ;

The word dup duplicates the top item on the stack. The <-> stands for filling in that part of the XML document with an item from the stack.

Implementation and libraries

Factor includes a large standard library, written entirely in the language. These include

A foreign function interface is built into Factor, allowing for communication with C, Objective-C and Fortran programs. There is also support for executing and communicating with shaders written in GLSL.[5][11]

Factor is implemented in Factor and C++. It was originally bootstrapped from an earlier Java implementation. Today, the parser and the optimizing compiler are written in the language. Certain basic parts of the language are implemented in C++ such as the garbage collector and certain primitives.

Factor uses an image-based model, analogous to many Smalltalk implementations, where compiled code and data are stored in an image.[12] To compile a program, the program is loaded into an image and the image is saved. A special tool assists in the process of creating a minimal image to run a particular program, packaging the result into something that can be deployed as a standalone application.[5][13]

The Factor compiler implements many advanced optimizations and has been used as a target for research in new optimization techniques.[5][14]

References

  1. ↑ Diggins, Christopher (2008), "Simple Type Inference for Higher-Order Stack-Oriented Languages", (PDF) http://www.cat-language.com/Cat-TR-2008-001.pdf Missing or empty |title= (help)
  2. ↑ Herzberg, Dominikus; Reichert, Tim (2009), "Concatenative Programming: An Overlooked Paradigm in Functional Programming", (PDF) http://mitarbeiter.hs-heilbronn.de/~herzberg/Publications/ICSOFT.2009.pdf Missing or empty |title= (help)
  3. ↑ Pestov, Slava, "Slava Pestov's corner of the web", http://factorcode.org/slava/ Missing or empty |title= (help)
  4. ↑ "Concatenative.org wiki: Factor/Implementation History", http://concatenative.org/wiki/view/Factor/Implementation%20history Missing or empty |title= (help)
  5. 1 2 3 4 5 6 7 Pestov, Sviatoslav; Ehrenberg, Daniel (2010). "Factor: a dynamic stack-based programming language". SIGPLAN Not. ACM. 45 (12): 43–58. doi:10.1145/1899661.1869637.
  6. ↑ Pestov, Slava, "Factor documentation: UI framework", http://docs.factorcode.org/content/article-ui.html Missing or empty |title= (help)
  7. ↑ Coleman, Doug, "Factor documentation: Database library", http://docs.factorcode.org/content/article-db.html Missing or empty |title= (help)
  8. ↑ Pestov, Slava, "Factor documentation: HTTP server", http://docs.factorcode.org/content/article-http.server.html Missing or empty |title= (help)
  9. ↑ Pestov, Slava, "Factor documentation: Specialized arrays", http://docs.factorcode.org/content/article-specialized-arrays.html Missing or empty |title= (help)
  10. ↑ Coleman, Doug; Ehrenberg, Daniel, "Factor documentation: Regular expressions", http://docs.factorcode.org/content/article-regexp.html Missing or empty |title= (help)
  11. ↑ Pestov, Slava, "Overhauling Factor's C library interface", http://factor-language.blogspot.com/2010/07/overhauling-factors-c-library-interface.html Missing or empty |title= (help)
  12. ↑ Pestov, Slava, "Factor's bootstrap process explained", http://factor-language.blogspot.com/2010/01/factors-bootstrap-process-explained.html Missing or empty |title= (help)
  13. ↑ Pestov, Slava, "On shaking trees", http://factor-language.blogspot.com/2008/07/on-shaking-trees.html Missing or empty |title= (help)
  14. ↑ Ehrenberg, Daniel (2010), "Closure elimination as constant propagation", (PDF) http://factorcode.org/littledan/abstract.pdf Missing or empty |title= (help)

External links

This article is issued from Wikipedia - version of the 11/29/2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.