From: Didi on
> These all derive from the functioning of the brain. It has been
> experimentally determined that the human brain cannot accurately
> keep track of more than roughly six or seven entities at once.
> This is known as the 'rule of seven'.

That's interesting to know, I had only a "feeling" based on my own
experience. I (like most others, I suppose) have become used to
writing just labels with some subroutines (functions, whatever) which
return "to be written" error status so I can begin debugging as early
as practical.
I would say my limit is between 100 and 1000 lines at once
(vpa or 68k or, well, 6800/09/11 assembly etc.) depending on
how much of the effort is coding and how much algorithm development.
The latter can actually make the 100 look unreachable sometimes.
The piece of code I have been preparing in my head for weeks
(without having the hardware to run it on, I had to decide whether to
build the hardware based on that code feasibility and it was
as marginal as it gets) was the real time loop of a TI DSP,
I had to make sure things would work within 10 cycles.... they did.
More basically, I would say if I don't have a binary to run after the
first
day of coding things don't look good :-). (I have not thrown away many
days' typings because of that but not so few either).

Dimiter

------------------------------------------------------
Dimiter Popoff Transgalactic Instruments

http://www.tgi-sci.com
------------------------------------------------------

On Feb 8, 6:35 am, CBFalconer <cbfalco...(a)yahoo.com> wrote:
> rickman wrote:
> > CBFalconer <cbfalco...(a)yahoo.com> wrote:
> >> Didi wrote:
>
> ... snip ...
>
> >>> The most critical rule I believe I have defined for myself is
> >>> "never write at once more than you can hold in your head".
> >>> After debugging a piece which is < your brain capacity, move
> >>> on to the next piece :-).
>
> >> The corollary to that is "keep your functions short. One
> >> screenful is usually enough"/
>
> > Interesting. I was taught (back in the days of a CRT being a
> > separate entity from the computer) the screenful rule of "thumb".
> > But I have been working lately with Forth and am becomming a firm
> > believer in the smaller the routine, the better. This certainly
> > works in Forth and works well.
>
> These all derive from the functioning of the brain. It has been
> experimentally determined that the human brain cannot accurately
> keep track of more than roughly six or seven entities at once.
> This is known as the 'rule of seven'.
>
> --
> <http://www.cs.auckland.ac.nz/~pgut001/pubs/vista_cost.txt>
> <http://www.securityfocus.com/columnists/423>
>
> "A man who is right every time is not likely to do very much."
> -- Francis Crick, co-discover of DNA
> "There is nothing more amazing than stupidity in action."
> -- Thomas Matthews


From: Andreas Kochenburger on
"David Brown" <david(a)westcontrol.removethisbit.com> schrieb im Newsbeitrag
news:45cae1cb$0$24618$8404b019(a)news.wineasy.se...
> Connect the Lua interpreter to a serial port interface, and you've got an
> extendible programmable command line interface into the heart of your
> program. I've done this a couple of times - I should get in the habit of
> doing it more.

If you want to do it in Forth with a smaller footprint than Lua's, have a
look at FICL.
http://ficl.sourceforge.net/


From: rickman on
On Feb 7, 11:35 pm, CBFalconer <cbfalco...(a)yahoo.com> wrote:
> rickman wrote:
> > CBFalconer <cbfalco...(a)yahoo.com> wrote:
> >> Didi wrote:
>
> ... snip ...
>
> >>> The most critical rule I believe I have defined for myself is
> >>> "never write at once more than you can hold in your head".
> >>> After debugging a piece which is < your brain capacity, move
> >>> on to the next piece :-).
>
> >> The corollary to that is "keep your functions short. One
> >> screenful is usually enough"/
>
> > Interesting. I was taught (back in the days of a CRT being a
> > separate entity from the computer) the screenful rule of "thumb".
> > But I have been working lately with Forth and am becomming a firm
> > believer in the smaller the routine, the better. This certainly
> > works in Forth and works well.
>
> These all derive from the functioning of the brain. It has been
> experimentally determined that the human brain cannot accurately
> keep track of more than roughly six or seven entities at once.
> This is known as the 'rule of seven'.

I recall a thread somewhere that discussed the origin of this "rule".
That conversation traced it to a paper by one of the participants in
the thread who said his original paper had to do with perception, not
thinking. He claimed that the human senses could distinguish easily
approximately seven levels of volume, tone, color and so on. That is
not to say that we can only see seven colors, but if you were to
attach them to objects or menus or similar, using much more than seven
makes them hard to distinguish.

I'm not disagreeing that seven is a good number for things you can
hold in your head short term, I am saying that I have not seen a
source for this claim. I'm pretty sure the magic number for me is a
bit less, perhaps five. That may be why I have trouble with the stack
when I program in Forth and have to make extensive use of stack
notation.




From: rickman on
On Feb 8, 5:06 am, "Andreas Kochenburger" <a...(a)nospam.org> wrote:
> "David Brown" <d...(a)westcontrol.removethisbit.com> schrieb im Newsbeitragnews:45cae1cb$0$24618$8404b019(a)news.wineasy.se...
>
> > Connect the Lua interpreter to a serial port interface, and you've got an
> > extendible programmable command line interface into the heart of your
> > program. I've done this a couple of times - I should get in the habit of
> > doing it more.
>
> If you want to do it in Forth with a smaller footprint than Lua's, have a
> look at FICL.http://ficl.sourceforge.net/

I would love to use Forth, but right now there are no Forth vendors
that support the ARM Cortex-M3 chips. I took a look at using FICL on
an embedded target and it would take a fair amount of work to port it
to such chips. Like most open source Forths, FICL is set up to run on
a PC host. It has been a few years since I looked at FICL, so if I am
mistaken, please let me know. But I don't think FICL is really
intended for embedded use unless you are embedding a PC like device.


From: Vladimir Vassilevsky on


CBFalconer wrote:


>
> These all derive from the functioning of the brain. It has been
> experimentally determined that the human brain cannot accurately
> keep track of more than roughly six or seven entities at once.
> This is known as the 'rule of seven'.

That is very optimistic. Most of people can't track even the single thing :)

VLV