Factor (programming language): Difference between revisions

Revision as of 04:31, 6 November 2014

Latest revision as of 04:01, 17 August 2025

(45 intermediate revisions by 33 users not shown)

Line 1:

{{Short description|Stack-oriented programming language}}

{{Primary sources|date=July 2019}}

{{Infobox programming language

|name = Factor

|logo = [[File:NewFactorLogo.png|200px]]

|paradigm = [[multi-paradigm programming language|multi-paradigm]]: [[functionalconcatenative programming language|functionalconcatenative]], ([[concatenativestack-oriented programming|stack-based]]), language[[functional programming|concatenativefunctional]], [[stackobject-oriented programming language|stackobject-oriented]]

|year = 2003

|developer = Slava Pestov

|latest_release_version = 0.96100

|latest_release_date = {{releasestart date|mf=yes2024|20139|4|2011}}

|typing = [[strong typing|strong]], [[dynamic typing|dynamic]]

|influenced_by = [[Joy (programming language)|Joy]], [[Forth (programming language)|Forth]], [[Lisp (programming language)|Lisp]], [[Self (programming language)|Self]]

|influenced = [[Cat (programming language)|Cat]],<ref>{{citation

|operating_system = [[Microsoft Windows|Windows]], [[Mac OSmacOS]], [[Linux]], others

| url = http://www.cat-language.com/Cat-TR-2008-001.pdf

| first = Christopher

| last = Diggins

| contribution = Simple Type Inference for Higher-Order Stack-Oriented Languages

| year = 2008

}}</ref> [[Concat (programming language)|Concat]]<ref>{{citation

| first = Dominikus

| last = Herzberg

| first2 = Tim

| last2 = Reichert

| year = 2009

| contribution = Concatenative Programming: An Overlooked Paradigm in Functional Programming

| url = http://mitarbeiter.hs-heilbronn.de/~herzberg/Publications/ICSOFT.2009.pdf

}}</ref>

|operating_system = [[Microsoft Windows|Windows]], [[Mac OS]], [[Linux]], others

|license = [[BSD license]]

|website = [http://factorcode.org/ factorcode.org]

}}

'''Factor''' is a [[stack-oriented programming language|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 [[compiler optimization|optimizing compiler]] and an [[Integrated development environment|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]].<ref>{{citationcite web | url = httphttps://factorcode.org/slava/ | first = Slava | last = Pestov | contributiontitle = Slava Pestov's corner of the web}}</ref> The initial implementation, now referred to as JFactor, was implemented in [[Java (programming language)|Java]] and ran on the [[Java Virtual Machine]]. Though the early language resembled modern Factor superficially in terms of [[syntax (programming languages)|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 aroundon manipulating Java objects with Java's [[reflection (computer science)|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 youthe programmer could define yourtheir own [[class (computer science)|class]]es, and early versions of native Factor were the same; the language was similar to [[Scheme (programming language)|Scheme]] in this way. Today, the object system is a central part of Factor. Other important language features such as [[tuple]] classes, combinator inlining, [[macro (computer science)|macro]]s, 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 (programming language)|C]] part of the implementation for each external [[library (computing)|library]] that Factor should communicate with, and has the benefit of being more [[declarative programming|declarative]], faster to compile and easier to write.

The Java implementation initially consisted of just an [[interpreter (computing)|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.<ref>{{citationcite web | url = httphttps://concatenative.org/wiki/view/Factor/Implementation%20history | contributiontitle = Concatenative.org wiki: Factor/Implementation History}}</ref>

==Description==

==Programming paradigm==

Factor is a [[dynamically typed]], [[functional programming|functional]] and [[object-oriented programming|object-oriented]] [[programming language]]. Code is structured around small procedures, called words. In typical code, these are 1-31–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.<ref name="dls">{{cite journal |last1=Pestov |first1=Sviatoslav |last2=Ehrenberg |first2=Daniel |year=2010 |title=Factor: a dynamic stack-based programming language |journal=ACM SIGPLAN Not.Notices |volume=45 |issue=12 |pages=43–58 |publisher=ACM |doi=10.1145/1899661.1869637 }}</ref>

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

"hello world" print

<code>print</code> is a word in the <code>io</code> 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).<ref name = "dls" />

The [[factorial|factorial function]] <math>n!</math> can be implemented in Factor in the following way:

Not all data has to be passed around only with the stack. [[Lexical scoping|Lexically scoped]] local variables let you store and access [[temporary variable|temporaries]] used within a procedure. [[Dynamic scoping|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.<ref name="dls" />

<syntaxhighlight lang="factor">

: factorial ( n -- n! ) dup 1 > [ [1..b] product ] [ drop 1 ] if ;

</syntaxhighlight>

Not all data has to be passed around only with the stack. [[Lexical scoping|Lexically scoped]] local variables let youone store and access [[temporary variable|temporaries]] used within a procedure. [[Dynamic scoping|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.<ref name="dls" />

Factor emphasizes flexibility and the ability to extend the language.<ref name = "dls" /> 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 [[literal (computer science)|literal]]s 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:

<syntaxhighlight lang="factor">

: make-html ( string -- xml )

dup

Line 54 ⟶ 49:

<html>

<head><title><-></title></head>

&lt;<body>&lt;<h1><->&lt;</h1>&lt;</body>

</html>

XML> ;

</syntaxhighlight>

The word <code>dup</code> duplicates the top item on the stack. The <code>&lt;-></code> 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 cross-platform GUI toolkit, built on top of [[OpenGL]] and various windowing systems, used for the development environment.<ref>{{citationcite web | url = httphttps://docs.factorcode.org/content/article-ui.html | contributiontitle = Factor documentation: UI framework | first = Slava | last = Pestov}}</ref>

* Bindings to several database libraries, including [[PostgreSQL]] and [[SQLite]].<ref>{{citationcite web | url = httphttps://docs.factorcode.org/content/article-db.html | contributiontitle = Factor documentation: Database library | first = Doug | last = Coleman}}</ref>

* An [[HTTP]] server and client, with the Furnace web framework.<ref>{{citationcite web | url = httphttps://docs.factorcode.org/content/article-http.server.html | contributiontitle = Factor documentation: HTTP server | first = Slava | last = Pestov}}</ref>

* Efficient homogeneous arrays of integers, floats and C structs.<ref>{{citationcite web | url = httphttps://docs.factorcode.org/content/article-specialized-arrays.html | contributiontitle = Factor documentation: Specialized arrays | first = Slava | last = Pestov}}</ref>

* A library implementing regular expressions, generating machine code to do the matching.<ref>{{citationcite web | url = httphttps://docs.factorcode.org/content/article-regexp.html | contributiontitle = Factor documentation: Regular expressions | firstfirst1 = Doug | lastlast1 = Coleman | first2 = Daniel | last2 = Ehrenberg}}</ref>

A [[foreign function interface]] is built into Factor, allowing for communication with [[C (programming language)|C]], [[Objective-C]] and [[Fortran]] programs. There is also support for executing and communicating with shaders written in [[GLSL]].<ref name="dls"/><ref>{{citationcite web | first = Slava | last = Pestov | url = httphttps://factor-language.blogspot.com/2010/07/overhauling-factors-c-library-interface.html | contributiontitle = Overhauling Factor's C library interface| date = 28 July 2010 }}</ref>

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 [[system image|image]]-based model, analogous to many [[Smalltalk]] implementations, where compiled code and data are stored in an image.<ref>{{citationcite web | first = Slava | last = Pestov | url = httphttps://factor-language.blogspot.com/2010/01/factors-bootstrap-process-explained.html | contributiontitle = Factor's bootstrap process explained| date = 10 January 2010 }}</ref> 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.<ref name="dls"/><ref>{{citationcite web | first = Slava | last = Pestov | url = httphttps://factor-language.blogspot.com/2008/07/on-shaking-trees.html | contributiontitle = On shaking trees| date = 5 July 2008 }}</ref>

The Factor compiler implements many advanced optimizations and has been used as a target for research in new optimization techniques.<ref name="dls"/><ref>{{citationcite web| first = Daniel | last = Ehrenberg | contribution title= Closure elimination as constant propagation | url = http://factorcode.org/littledan/abstract.pdf | year=2010 |url-status=dead 2010|archive-url=https://web.archive.org/web/20110726044425/http://factorcode.org/littledan/abstract.pdf |archive-date=2011-07-26 }}</ref>

==References==

{{reflistReflist}}

==External links==

*{{Official website|http://factorcode.org}}

*{{cite video |people=Slava Pestov |date=October 27, 2008 |title=Factor: An Extensible Interactive Language |url=httphttps://www.youtube.com/watch?v=f_0QlhYlS8g |archive-url=https://ghostarchive.org/varchive/youtube/20211222/f_0QlhYlS8g |archive-date=2021-12-22 |url-status=live|format=flv |medium=Tech talk |publisher=[[Google]]}}{{cbignore}}

*{{cite video |people=Zed Shaw |date=2008 |title=The ACL is Dead|url=http://vimeo.com/2723800 |format=flv |medium=CUSEC 2008 |publisher=[[Canadian University Software Engineering Conference|CUSEC]]}} – a presentation written in Factor which mentions and praises Factor

{{DEFAULTSORT:Factor (Programming Language)}}

[[Category:Programming languages]]

[[Category:Concatenative programming languages]]

[[Category:Function-level languages]]

[[Category:Stack-oriented programming languages]]

[[Category:Programming languages created in 2003]]

[[Category:Extensible syntax programming languages]]

[[Category:2003 software]]

[[Category:High-level programming languages]]

[[Category:Software using the BSD license]]