OK, I'm hooked. I was trying to avoid learning another new language--
especially since I was in the middle of trying to systematize my
haphazard knowledge of C. But I find Factor ... strangely compelling.
Anyway, thought I should briefly introduce myself. I've been around open
source development since the end of the last millennium; worked in "the
industry" for a couple of years--I was an XML consultant, but later
realized I didn't like XML much--or at least not the kinds of XML
applications that were getting most of the attention at that time.
Recently I've been making my living in other (mostly unpleasant) ways,
but have continued to program open-source software, though I haven't
worked on anything mainstream ... mainly, I suppose, because I
vehemently disagree with most mainstream thinking about how software,
and particularly user interfaces, should be designed.
I've done substantial work in (chronologically) Python, Java <ugh>
(yeah, sorry Slava, I loved jEdit, which is one of the reasons I was
willing to try Factor, but I detest Java, and that's all I will say
about it unless somebody deliberately provokes me :-), and OCaml. Done a
bit of work w/ Tcl, Ruby, Chicken Scheme, and C; played around w/
Haskell, Prolog, Eiffel, and a few others. Sounds like I'm a language
junkie, huh?
Anyway, my first thoughts when I encountered factorcode.org were, "Hmm,
this is weird," and "'Practical'? Yeah, right!" And having tried in the
past to understand bits of PostScript (gulp!) and having read part of an
introduction to Joy, which I found utterly incomprehensible, I really
had doubts about a stack-based language. But I could see that Factor at
least had an extensive library and lots of documentation, so I guess
that was enough that I decided to come back and try it. I've been
learning Factor for 3 or 4 days, and it is gradually starting to make sense.
Here, for what they're worth, are a few random observations from a newcomer:
* Most open-source languages I've seen are just languages, and their
developers often seem to have a cavalier attitude toward the
numerous challenges of developing and deploying real-world
applications. Factor is a (nearly) complete development toolkit; I
think that if people can overcome their initial fear of the
unfamiliar syntax, that fact alone will go far toward persuading them
to adopt Factor for their projects.
* The workspace is awesome--IMHO the approach of providing
an interpreter, debugging and build tools, and documentation all in
one place, while allowing people to use their favorite editors, is
just what we need. The only thing I can see that's really lacking (or
maybe I just haven't discovered it yet) is an interface to version
control systems. Does anybody do serious development without some
form of version control?
* While the easy access to documentation is great, and the reference
material appears to be very good, I think there is room for a lot of
improvement in the tutorial content. Now, I'm not sure who the
intended audience is--it seems unlikely at this stage that many
brand-new programmers will encounter Factor, and I imagine most
newcomers are something like me: with or without CompSci degrees (I
am without), but with significant programming experience and an
interest in learning new languages and approaches. People like me
don't need a *lot* of help, but we might need some--more on that
below. What concerns me here is the hypothetical newbie whose
background is entirely with mainstream procedural/OO languages. I
think their brains will hurt and they will run away. And maybe that's
okay. There is something to be said for an elitist, sink-or-swim
approach--keeps the mailing list from getting clogged up with dumb
questions. But I get the impression that this community intends to
welcome anybody who wants to learn--in which case I have some
suggestions:
- Consider renaming and restructuring the Cookbook. Every other
programming "Cookbook" I have seen is a collection of realistic
examples intended for programmers with some experience--what you
might call "journeymen"--trying to solve real-world problems;
usually each "recipe" stands on its own. Beginners, IMHO, tend to
do better with a sequence of chapters, each building on the
previous ones. Not that there is any single correct sequence for
learning a programming language or anything else. But any structure
provided by a knowledgeable writer is likely to be better than no
structure at all.
- Try to provide series of related examples, gradually increasing in
complexity/difficulty. I think the book _Practical Common Lisp_
does this very well.
- Although stack manipulation is a fairly simple concept (compared
to, say, monads in Haskell or call/cc in Scheme), real programs
are composed of many stack operations, and it can be hard to
follow. In the early stages of learning, step-by-step explanations
and/or diagrams would be very helpful.
- I think experts in any given language tend to underestimate the
difficulty of syntactic details. For example, what are the rules
for using semicolons? It is confusing that a USES: declaration
ends with a semicolon, but not an IN: declaration.
If I stick with Factor--and I think at this point I probably will--
when I gain enough understanding of the language I might be able to
help improve the beginners' documentation. I have done some technical
(and other) writing in the past.
* Learners with more experience and/or a more adventurous spirit might
not need a complete tutorial, but might need concise statements of
rules and definitions. For example, I'm trying to understand how to
do macros in Factor. It appears that the concept of a static stack
effect is important in relation to macros, but I can't find a
definition for that concept anywhere. I imagine it is roughly
equivalent to referential transparency in a functional language, but
even if that guess is correct, it is imprecise, and furthermore I
have no idea how to recognize whether a word has a static stack
effect or not (BTW I will ask this question shortly in a separate
post, so no need to provide an answer here).
* One thing I really like about Factor is a quality that some might
call "expressiveness" ... but that's not exactly what I mean. I would
say, rather, that it enables a high degree of *fluency*. It
gets out of the way and lets you write your ideas into code. The
feeling is something like using a good chef's knife--as you gain
mastery, the tool becomes a barely-noticeable extension of your hand.
I think the last time I had that feeling to the extent I do with
Factor was when I started using Vim after 5 years with Emacs. I am
still using Vim today, and while I can imagine there being a better
editor, I haven't found one.
* The optimizing compiler (v. 0.92) is *horrendously* slow on my
machine. I didn't time it, but I think it took about 15 minutes to
compile the Tetris demo. A comparable program in OCaml would compile
in less than 30 seconds. That's probably an unfair comparison, but
still ... So, are there any plans to speed up the compiler? Or are
there ways to compile faster with the current compiler?
--
Matt Gushee
: Bantam - lightweight file manager : matt.gushee.net/software/bantam/ :
: RASCL's A Simple Configuration Language : matt.gushee.net/rascl/ :
------------------------------------------------------------------------------
Open Source Business Conference (OSBC), March 24-25, 2009, San Francisco, CA
-OSBC tackles the biggest issue in open source: Open Sourcing the Enterprise
-Strategies to boost innovation and cut costs with open source participation
-Receive a $600 discount off the registration fee with the source code: SFAD
http://p.sf.net/sfu/XcvMzF8H
_______________________________________________
Factor-talk mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/factor-talk
