In context, I thought I was mentioning it after I had counseled you to try a
factor code-compile-test cycle that wasn't perfectly what you desired to
just get going and have fun. I just didn't want you to think I was trying
to shut down non-orthodox ideas - factor to me represents just the opposite.
Which I remember as a problem with forth - everyone did everything their own
way and reinvented many wheels, so it was too hard to get started for a
casual person.
I sense that I'm running in too many directions with Factor. First, I need
to get a minimal regular Emacs config that just works for me most of the
time, like the one Slava is using in his video of Factor-with-Emacs, where
he build the simple GUI app and the TCP time server. I'll do that tonight.
I appreciated the tutorial showing very cogently how easy coding and
co-testing are--in fact, how desirable testing-to-build is. This is one of
Factor's best features. A testing "harness" doesn't get any lighter.
I still have no significant stack discipline. I don't practice much
code-writing yet. I'm still playing with demos, and reading about the
language. I'm especially interested in Joe's OpenGL shader demo, Furnace
and anything to do with composing and serving a blog (by this, I mean a very
rich hypermedia document created by one person and viewed by many), and
general-purpose PEG facilities, like those in VisualWorks XStreams
framework:
http://www.michaellucassmith.com/20100227%20Xtreams%20Primer.html
http://www.michaellucassmith.com/20100428%20Xtreams%20marshaler.html
http://www.michaellucassmith.com/20100502%20Xtream%20sharing.html)
I am concerned that there is little to no drive among those here fluent in
their Factor stack discipline/shuffle-patterns to build up and out of this
layer or grade of words (one close to the metal) into a pure domain-level
grammar (for any domain) free of shuffling or any need to be aware of it
while using the domain-level words to do practical work, like configuring
and starting a web server, for example. This separation of the layers
seems difficult, and the bleed-through seems very common. Become good
enough with your stack discipline, and soon you may not care much about
simpler more approachable DSLs. That is my worry--that drive in this
direction varies inversely with Factor stack discipline.
I agree with prunedtree's recent comments, the gist of which is: if you are
thinking about your domain logic and stack shuffling at the same time,
you've messed up. I agree. Getting this layering effect in the vocabs to
work without limiting machine-efficiency is my main goal. I want the
optimizing compiler to be able to unswizzle the swizzles I create to ease
human reading and thinking. I think some of this already happens, but do
not know how far it goes.
I'm noticing that Factor reading is not very efficient, because it taxes
human memory. I know that I will be more fluent eventually, but, for now:
I have the places on the stack to watch and to keep in order in my mind, the
types of the entities in those slots to watch (in my mind because they are
not often named), and the before/after stack state to remember or watch in
the status bar, all in order to read Factor fluently, one word to the next.
That process is heavy until stack discipline is firm and lots of memories of
stack-effects have been cemented. I'm not sure that is a good basic
constraint to have in a language. But I'm not convince that long
self-documenting words (with extra bits about before/after stack state) are
the answer, either.
I'm hungry for local variables, now, though this goes against much of the
basis of stack languages. I want lexical forms I can read and understand
(parse with my mind, left-to-right, and down in a tree) to produce a known
result (not a best guess). I don't want to remember a lot of stuff, because
human memory is fragile and ultimately limits all programmers. I know that
we have a "locals" vocab of some kind, but don't know how to use it. Is
anyone using locals a lot in Factor just for readability? Can locals be
used efficiently for the machine, too? How can locals be abused?
I like explicitly clear code with a semantic focus on the values that are
being produced, what they are named and where they live (stack, locals).
Transitive verbs, so popular in all programming language, whether used in
words or methods or functions or procedures or whatever are weak to useless
at communicating what you are getting, where it's coming from and where it's
landing. Verbs/action concepts in programming languages provide excellent
background context for the values being computed during those verb/action
intervals, but code that emphasizes them strongly without strong focus on
values computed, tends to be noisy and hard to
read/understand/remember/discuss. I want to work this focus on values into
a basic CRUD DSL in Factor. I need to be able to write a parser in a
straightforward way (XStreams-style maybe) using a PEG (collection of BNF
productions) so that I can experiment efficiently with this idea. Does
anyone have any experience with PEGs in Factor?
Also, I need a tree control (with expandable/collapsible nodes). Do we have
one that works well?
Shaping
------------------------------------------------------------------------------
The Next 800 Companies to Lead America's Growth: New Video Whitepaper
David G. Thomson, author of the best-selling book "Blueprint to a
Billion" shares his insights and actions to help propel your
business during the next growth cycle. Listen Now!
http://p.sf.net/sfu/SAP-dev2dev
_______________________________________________
Factor-talk mailing list
Factor-talk@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/factor-talk
