Factor/FAQ/Why?

What is the purpose of the Factor's project?

Factor is an experiment to build a modern, useful Concatenative language with strong abstraction capabilities and good support for Interactive development.

What makes Factor unique?

Factor combines traits which are rarely all seen together in the same language:

• Concatenative language
• Dynamic typing
• Expressiveness
• Good performance
• Interactive development
• Application deployment
• Good library

What is Factor's specialty? Where is it best used?

Factor is a general-purpose programming language which currently runs on various popular desktop and server systems. In the future it will also run on high-end mobile devices, although there are no plans to scale the language down into deeply embedded devices with little memory or no OS. A bare minimum would be about 128Mb of RAM to fit an operating system and Factor and still have room left over for user code. Factor has been used for everything from scripting, web applications (see Furnace), games, and XML parsers.

Why is Factor stack-based?

Concatenative and stack-based languages have not received much attention from the programming community ever since Forth began a slow decline in the 80's. The Concatenative language page discusses some advantages of this programming paradigm. Once you learn some common idioms, many problems can be more cleanly expressed in a concatenative language compared to an applicative language.

Is Factor cross-platform?

Though Factor images can only run on one specific platform, the same Factor source code can easily be run on any platform that Factor is ported to. Portability issues only occur when interfacing with native libraries, or if there is a bug.

How is Factor different from Forth?

Forth is untyped, not garbage collected, and close to the machine. For flow control, Forth code tends to use immediate words. Variables and arrays tend to be global, and programs aren't usually written in a functional manner. Factor is very different from this. It is dynamically typed, offering a high degree of reflection. Unreferenced objects are garbage collected with a generational garbage collector. Factor code is a little bit more distant from the machine, though the C FFI allows using words like malloc and mmap. For flow control, Factor generally uses quotations, allowing flexible higher order functions; parsing words are used mostly for definitions and data literals. Variables are dynamically or statically scoped (see below), and arrays are just objects which don't need to be treated specially.

If Factor programs are just compositions of existing words, how is Factor as powerful as other programming languages?

Factor is a Turing-complete programming language whose programs are capable of doing whatever any other programming language can do. In fact, it isn't all that complicated to translate between a stack-based language and an applicative one, as long as it's known how many arguments the words in the stack-based language take.

Why do we need a new stack-based language?

Because the other ones aren't suitable for high-level development. Forth is great for low-level things, but its lack of type system and garbage collection make it difficult to debug programs, and it doesn't mesh well with functional programming. Joy made a very important theoretical contribution, but it is difficult to compile efficiently, its syntax is inextensible and it has an insufficient module system. Additionally, it is almost purely functional, making many things difficult. Factor combines the best aspects of these two systems, together many other borrowings from various places.