Content deleted Content added
m Task 18 (cosmetic): eval 14 templates: del empty params (1×); |
m Bot: http → https |
||
| (17 intermediate revisions by 14 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]]: [[
|year = 2003
|developer = Slava Pestov
|latest_release_version = 0.
|latest_release_date = {{
|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]]
Line 19 ⟶ 20:
==History==
Slava Pestov created Factor in 2003 as a [[scripting language]] for a [[video game]].<ref>{{cite web | url =
The language has changed significantly over time. Originally, Factor programs centered on 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
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>{{cite web | url =
==Description==
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–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 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
"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
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:
Line 51 ⟶ 57:
==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>{{cite web | url =
* Bindings to several database libraries, including [[PostgreSQL]] and [[SQLite]].<ref>{{cite web | url =
* An [[HTTP]] server and client, with the Furnace web framework.<ref>{{cite web | url =
* Efficient homogeneous arrays of integers, floats and C structs.<ref>{{cite web | url =
* A library implementing regular expressions, generating machine code to do the matching.<ref>{{cite web | url =
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>{{cite web | first = Slava | last = Pestov | url =
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>{{cite web | first = Slava | last = Pestov | url =
The Factor compiler implements many advanced optimizations and has been used as a target for research in new optimization techniques.<ref name="dls"/><ref>{{cite web|first=Daniel |last=Ehrenberg |title=Closure elimination as constant propagation |url=http://factorcode.org/littledan/abstract.pdf |year=2010 |url-status=dead |archive-url=https://web.archive.org/web/20110726044425/http://factorcode.org/littledan/abstract.pdf |archive-date=2011-07-26 }}</ref>
Line 70 ⟶ 76:
==External links==
*{{Official website|http://factorcode.org}}
*{{cite video |people=Slava Pestov |date=October 27, 2008 |title=Factor: An Extensible Interactive Language |url=https://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=CUSEC}} – a presentation written in Factor which mentions and praises Factor
| |||