Factor 0.97 now available | Hacker News Reader

Factor 0.97 now available

re-factor.blogspot.com

92 pointsotoburb18 comments

5 or 6 years ago the language got a good amount of hype and was progressing rapidly. It's been a long time since 0.96. Why has there been such a long delay?

(not a criticism, just a question)

0.96 was released April 20, 2013[1] and was rather solid to use. Glad to hear that it received a fair amount of hype before (I wasn't aware of that myself -- perhaps I missed that phase). Most languages seem to release rapidly as 'low-hanging fruit' features are worked on, and then seem to plateau as major releases get longer and longer in between.

Factor came to my attention during the 0.94 release in 2010, which was solid enough to learn Factor in a great IDE. I wish that I'd had more time to invest more seriously over the years, but am extremely glad that it's still being actively worked on. You can tell this from the Factor github commit log[2].

As far as I'm aware, since the community is rather small, most people that code in Factor don't bother much with the release numbers and just compile their images straight from github as commits are made. The "releases" are done more as a public milestone.

[1] http://re-factor.blogspot.com/2013/04/factor-0-96-now-availa...

[2] https://github.com/slavapestov/factor/commits/master

The releases have varied over the years from less than a year, to almost two years between "releases". For some historical context:

0.93 was released April 16, 2010.

0.94 was released September 18, 2010 (+5 months).

0.95 was released August 16, 2012 (+23 months, 2500 commits).

0.96 was released April 20, 2013 (+9 months, 1100 commits).

0.97 was released November 1, 2014 (+19 months, 1400 commits).

The core developers (I am one) generally use the latest development version which, except for some changes to the build farm a few months ago, is made available as tested nightly builds from our build farm.

A partial reason for the delayed release was waiting for sufficient changes to "justify" a release (a bit of a soft qualitative delay, especially as we kept working on some new features). Going to a time-based release schedule might be nice, something to think about anyway.

Eh, the Rakudo Perl 6 implementation has been doing monthly releases since before 2010, and I don't get the impression that's done much to convince doubters. (Despite amazing progress since 2010.) Those of us working on developing it mostly grab the latest source from github and work from that, much the same as you guys.

Keep the faith, the world needs more powerful, offbeat languages!

Factor has always been developed by a relatively small team, which makes their achievements even more remarkable. The language's creator, Slava Pestov, was a very important driving force in its development until around 2011, when he stepped down from leading the project to focus on a new job at Google.

John Benediktsson has been leading the project since then, and as the post mentions, there are and have been many other contributors, but I think it's fair to say that the project lost a lot of momentum when Slava stepped down.

Joe Groff, who was another important early contributor, and who is now part of the Swift team at Apple, gave a talk that included an interesting critical retrospective on the factor project (or at least one chapter of it). I'm sure there was a better formatted version of it at some point, but this is all I could find:

https://github.com/jckarter/zissou/blob/master/talk-notes.tx...

See "bad parts" for the criticisms.

Incidentally, these notes were the first place that I learned of the Julia language.

As can be seen from his Github account, he also seems to have been the primary developer on the Clay programming language.

I'm glad to see that Factor is regaining some momentum. It made such good progress early on that it would be a shame if development didn't continue.

Factor seems to be the only modern[1], mature, actively developed concatenative language right now. But I'm not really a concatenator so I can't tell for sure.

[1] Though maybe some Forths can be considered modern.

Kitten is an exciting, actively developed, statically typed concatenative lang: http://kittenlang.org/

Yeah, I hope evincarofautumn keeps chugging along with it. Last I saw I liked the ideas/philosophy behind it. Nice to see that the front page has a more interesting code example than last time I checked the website out. Readable use of matrices must be one of the biggest doubts that people in general have when it comes to what concatenative languages can pull of cleanly.

Is it somehow related to Cat language (http://www.cat-language.com/)?

Yup, it is. From the FAQ:

"It’s also intended to be a practical successor to Cat, which was the first statically typed concatenative language."

People interested in both array/APL-like and concatenative languages might want to take a look at lang5.

Will we ever see a humane J-language binding? I would like to use it Factor-like.

Congrats for the release.

always been interested in learning a stack based language, but have been unsure about what sort of programs are interesting to build with this.

Factor is general-purpose and you can write most anything you want at this point.

Here's tar in Factor:

https://github.com/slavapestov/factor/blob/master/extra/tar/...

For untarring the linux kernel, Factor tar beats /usr/bin/tar on my Mac by 1s, but 30s vs 6s on Linux for some reason. Could be SSD vs spinning disk, or worse i/o code on Linux. Funnily, there are about 10 files that differ in case only, and Mac file system is case-insensitive by default, so you can't even untar the linux kernel correctly.

Here's host using the dns client library:

https://github.com/slavapestov/factor/blob/master/extra/tool...

https://github.com/slavapestov/factor/blob/master/extra/dns/...

I wrote it because gethostbyname is blocking and Factor has nonblocking i/o for everything else.

There's a cross-platform disk usage tool that outputs the same stuff as df but works on Windows too:

https://github.com/slavapestov/factor/blob/master/basis/tool...

    USE: tools.files file-systems.

There's a high-level library for doing whatever you want with unix users/groups:

https://github.com/slavapestov/factor/blob/master/basis/unix...

    effective-user-name [ ] with-effective-user
    effective-user-id [ ] with-effective-user
    all-users

https://github.com/slavapestov/factor/blob/master/basis/unix...

    effective-group-name [ ] with-effective-group
    effective-group-id [ ] with-effective-group
    all-groups

Graphics demo--raytraced spheres using GLSL on a checkerboard pattern, spheres each play their own music:

https://github.com/slavapestov/factor/tree/master/extra/gpu/...

https://github.com/slavapestov/factor/blob/master/extra/gpu/...

The main file that sets up the world and loads the shaders and sound is 130 lines and reuses the game library.

I remember playing with the JS "Cat" interpreter[0] in college to get my feet wet.

but for myself, the fun is in writing a toy concatenative language. The parsing difficulty borders on non-existent, making it easy to skip to thinking about semantics. once you actually try to implement programs within concatenative syntax, you will surely run into its main pitfalls: there are too many valid programs that produce wrong results, and there are whole new classes of errors introduced through having to maintain stack state yourself. writing code in this style can develop into a complex puzzle very quickly, although it's beautiful when it does work.

[0] http://www.cat-language.com/interpreter.html

The interesting thing about stacked based languages is not what you can build with them; it's the fact that you can build them yourself.

The whole idea of picking a Forth or another concatenative language off the shelf is spoiling 3/4th of the concept. The point of stack languages is that they are very easy to implement.

So don't learn a stack based language, make one and grow it until you can actually use it to make useful tools.

Reply on news.ycombinator.com