

Joy in Factor - fogus
http://github.com/inforichland/Joy/tree/master

======
mahmud
Life is too short to be good at two fringe programming languages, however
similar they are! :-P

~~~
olliesaunders
Is Factor getting more press these days? I'm seeing it mentioned increasingly
or maybe I just started paying attention.

~~~
dkersten
Slowly, yeah. Slava is still working hard on improving it and the community
_is_ slowly expanding.

However, Factor still has one problem: it takes a bit of a time investment to
get used to the Factor idioms and until you do, its horribly difficult to code
in. Once you do though, its an amazingly powerful language. Pity I need to
spend a _little_ longer at it.. time which I don't currently have to spare.
Hopefully in a few months though :-P

~~~
olliesaunders
Hm, yeah. Concatenative languages haven't had much attention, undeservingly.
I'm going to keep an eye on Factor I think. I'm already plunging into
functional programming these days though, there are so many languages to
learn!

~~~
dkersten
I LOVE concatenative languages. They intrigue me. That doesn't make it easier
when you're not used to it, however..

Same here, keeping a close eye on it. Its a VERY powerful language - like a
concatenative postfix modern Lisp.

~~~
davidw
I played around with Forth a while back, and while I thought it was a great
experience and an interesting way of 'seeing the world', I think that keeping
track of what's on the stack seemed like a route to madness. Even stuff like C
doesn't make you do that.

How do things like Factor improve on Forth?

~~~
dkersten
The Factor community likes to use the following phrase to answer that question
and I think its quite correct: "Idiomatic Factor does not use the stack".

That is, well written idiomatic Factor makes use of higher level abstractions
which hide the stack from you. The stack should not be used as a data
structure, but rather as a scratchpad to allow pointfree programming. Factor
provides a load of abstractions which can often handle all of that low level
stack handling stuff for you, making the code easier to read, follow and
understand (once you know the abstractions). Factor also provides local
variables, for use when it makes sense to name your data. Its not shunned to
use them over the stack - when it makes sense to. Finally, Factors macros
allow you to modify how the code is parsed (Factor calls them "parsing
words"), so you can actually change the syntax. Core Factor provides an
"infix" parsing word which allows you to write infix expressions and it is
advised to do so when it makes sense (eg, for mathematical formulas). Another
example of parsing words put to great use is Jeremy Hughes' inline C/C++
library, which basically allows you to write C/C++ code inline in Factor
source files. During compilation, Factor will compile this code with GCC and
simplifies writing of FFI stubs for wrapping C/C++ libraries.

Basically, Factor is very different from Forth. Slava likes to say that
"Factor has more in common with Lisp than it does with Forth" and its often
said that Factor only has a syntactical resemblance to Forth, but is otherwise
very different.

