Arduino Due - small FORTH Computer - Multitasking

[Mark Wills]

Ran into this by accident on YouTube:

https://www.youtube.com/watch?v=M-Xt1ShKW3c#t=162

EXACTLY what I'm looking for, though I don't know how fast
it is, or how well (if at all) it is documented as a system.

Anyone know anything about it?

Mark

[Mark Wills]

Info on the board here:

The Arduino Due is the newcomer microcontroller board in the Arduino boards family. It's the first board based on a 32 bit ARM core processor, the Atmel SAM3X8E ARM Cortex-M3 MCU, that improve all the standard Arduino functionalities and add more new features. It offer 54 digital input/output pins (of which 12 can be used as PWM outputs, with selectable resolution), 12 analog inputs with 12 bit of resolution, 4 UARTs (hardware serial ports), and two DAC outputs (digital to analog converter), 84 MHz crystal oscillator, two USB connections, a power jack, an ICSP header, a JTAG header, and a reset button.

http://www.amazon.co.uk/367/dp/B00A6C3JN2/ref=sr_1_1/279-7914403-4163034?ie=UTF8&qid=1436886148&sr=8-1&keywords=arduino+due

[Paul Rubin]

Mark Wills <markwi...@gmail.com> writes:
> EXACTLY what I'm looking for, though I don't know how fast
> it is, or how well (if at all) it is documented as a system.
> Anyone know anything about it?

Yes, see here: http://www.adafruit.com/products/1076

Arduinos have a big user community and tool ecosystem but the hardware
is kind of expensive for what you get. There are lots of comparable
boards that are much less expensive, e.g. the STM Discovery boards,
TI Launchpads, etc.

Be aware that the Arduino is not a "Forth board" as the youtube link
might have made it sound. It's a general purpose Cortex M3 board that
someone installed a Forth system on. It's not even clear which Forth
system. Normally they are programmed in C with a beginner-friendly
software setup called "sketches" (I'm not describing it perfectly, ok).
Part of what you pay for is the hardware and software support (special
bootloader etc) to accomodate that.

[Mark Wills]

Thanks Paul. It's a shame that the Forth system can't be identified.
It looks quite comprehensive. The author of the video doesn't appear
to be responding to requests for more info, so I guess I'll just leave
it there.

Mark

[Matthias Koch]

> Thanks Paul. It's a shame that the Forth system can't be identified.
> It looks quite comprehensive. The author of the video doesn't appear
> to be responding to requests for more info, so I guess I'll just leave
> it there.

Hi Mark,

so far, there are few Forths for ARM Cortex, the ones I know are:

m3forth by Cliff Biffle (https://bitbucket.org/cbiffle/m3forth/src)
coreforth by Eckhart Köppen (https://github.com/ekoeppen/CoreForth)

It is clearly not Mecrisp-Stellaris, as variable is used without initialisation value.
But if you wish for a Forth on your own Arduino Due, consider writing just another port of Mecrisp-Stellaris.

Matthias

[Stephen Pelc]

On Wed, 15 Jul 2015 14:02:46 +0200, Matthias Koch
<matthi...@hot.uni-hannover.de> wrote:

>> Thanks Paul. It's a shame that the Forth system can't be identified.
>> It looks quite comprehensive. The author of the video doesn't appear
>> to be responding to requests for more info, so I guess I'll just leave
>> it there.
>
>Hi Mark,
>
>so far, there are few Forths for ARM Cortex, the ones I know are:
>
>m3forth by Cliff Biffle (https://bitbucket.org/cbiffle/m3forth/src)
>coreforth by Eckhart Köppen (https://github.com/ekoeppen/CoreForth)

Ignoring Forths because they are not FOSS does not mean that they do
not exist.

Naturally, there are commercial Forths by MPE and Forth Inc. The MPE
one can have such extensions as a FAT file system, USB stack, TCP/IP
stack and son on. The commercial ones also have documentation. The
MPE VFX cross compiler includes a *really* good code generator.
There's a free (of charge) Lite version of the MPE compiler.

Stephen

--
Stephen Pelc, steph...@mpeforth.com
MicroProcessor Engineering Ltd - More Real, Less Time
133 Hill Lane, Southampton SO15 5AF, England
tel: +44 (0)23 8063 1441, fax: +44 (0)23 8033 9691
web: http://www.mpeforth.com - free VFX Forth downloads

[Matthias Koch]

Hi Stephen,

of course I know that you have developed a very good compiler with register allocation, available for many special CPU cores. Unlike yours, which enjoys having a lot of memory available for many optimisation cases, mine has to fit entirely in small chips. Yours clearly shows its strength in tethered mode, but to cite your Euroforth article:

http://www.complang.tuwien.ac.at/anton/euroforth/ef14/papers/pelc1.pdf

"In our world, the cross compiler generates highly optimised code, but we are not really concerned with the quality of the code created by the target."

This is exactly what I care about. Additionally, FOSS implementations neither have artificial limitations as your Lite compiler nor the requirement to sign an NDA to see the complete compiler sources.

Matthias

[Stephen Pelc]

On Thu, 16 Jul 2015 12:26:15 +0200, Matthias Koch
<matthi...@hot.uni-hannover.de> wrote:

>of course I know that you have developed a very good compiler with
>register allocation, available for many special CPU cores.

What I was asking for was to be acknowledged, just as I always
acknowledge systems like Mecrisp or other FOSS systems when asked
what is available.

>Unlike yours, which enjoys having a lot of memory available for many
>optimisation cases, mine has to fit entirely in small chips. Yours clearly
>shows its strength in tethered mode, but to cite your Euroforth article:
>
>http://www.complang.tuwien.ac.at/anton/euroforth/ef14/papers/pelc1.pdf
>
>"In our world, the cross compiler generates highly optimised code, but
>we are not really concerned with the quality of the code created by the
>target."

With a Raspberry Pi being cheaper than many Arduinos, we just decided
to go the Pi route where performance matters. In 10 years or so, the
majority of what are now deep-embedded systems are likely to be on
small boards with an OS of some sort. We have seen some truly dreadful
Linux implementations on such boards. The hard-real-time argument
will only apply to a very small proportion of developers and most of
them will not know what you are talking about.

>This is exactly what I care about. Additionally, FOSS implementations
>neither have artificial limitations as your Lite compiler nor the
>requirement to sign an NDA to see the complete compiler sources.

The FOSS versus proprietary argument is old and tired. It's just a
different business model - consultancy vs product.

MPE can and has put the full VFX code generator on a deep embedded
target.

However, in a work environment, trying to do deep embedded development
without a proper toolchain including something like a Segger J-Link
is just madness. In the C world, that's why companies like Rowley
are still in business and in the Forth world, companies like MPE
and Forth Inc. are still in business.

Just do not pretend that we do not exist.

[Walter Banks]

On 16/07/2015 6:26 AM, Matthias Koch wrote:
>Additionally, FOSS implementations
> neither have artificial limitations as your Lite compiler nor the
> requirement to sign an NDA to see the complete compiler sources.

I see the point on the Lite compiler, I don't see the
point of the NDA objection.

w..

[Matthias Koch]

I am a physicist and very curious on how it works internally. I simply would not recommend VFX for the hobbyist or the one who wishes to play with Forth internals. The in-target Lite compilers have their limits, and a NDA is not the right choice for FOSS freaks. The original question has been about Arduino Due, so I assumed an experimental environment.

Matthias

[Stephen Pelc]

On Mon, 20 Jul 2015 11:57:46 +0200, Matthias Koch
<matthi...@hot.uni-hannover.de> wrote:

>I am a physicist and very curious on how it works internally.

The internals are described in EuroForth papers. The real problems for
people who want to write good compilers are that
a) Pattern matching (Timbre style) compilers are a dead end in
terms of ultimate code quality.
b) Analytical compilers take a lot of effort to write and take a
while to mature.

>I simply would not recommend VFX for the hobbyist

The Lite compiler is ideal for hobbyists who do not require a
huge amount of optimised code. There is an upgrade path to the
inexpensive Stamp compiler.

> or the one who wishes to play with Forth internals.

You mean those who want the source code. The trouble is, when we did
not have an NDA on our source code, people ripped us off. Since we
introduced the NDA, we do not have that problem. Even the Lite
compiler comes with full source code for the target.

> and a NDA is not the right choice for FOSS freaks.

That's just politics and a different business model.

In the Forth world, if you want good code quality from a
production-grade compiler, you have to use a commercial one. The
reason MPE was able to do it was that we put together a team and
funding to produce the VFX compiler chassis and the first few
targets. There is nothing to stop a FOSS team doing the same.

[Walter Banks]

On 20/07/2015 5:57 AM, Matthias Koch wrote:
> I am a physicist and very curious on how it works internally. I simply
> would not recommend VFX for the hobbyist or the one who wishes to play
> with Forth internals. The in-target Lite compilers have their limits,
> and a NDA is not the right choice for FOSS freaks.

Part of my question has been answered by Stephen Pelc. If your stated
purpose is personal education then NDA's would permit that. What an NDA
could do is retain control how the information gets further distributed
after its acquired.

I have owned a compiler company for many years, each new compiler
project sets a new record on development costs. The development has to
be completed before there is any chance of recovering the costs.

That model encourages high risk innovation.

After development it easy to duplicate innovation that works perhaps
1000:1 to 10000:1 less expensive.

I get several emails a month with the general comment that they like
FOSS price but we produce much better code. Why do we refuse to be
price competitive? The real answer is we probably are, it takes a day
or two engineering costs to pay for one of our compilers about 60% of
which on average is returned to the customer in the form of support the
remaining costs are similar or less than to install a FOSS compiler.

Most of our support calls are not fundamentally about our tools but
about how to develop code for the target environment.

w..

[Paul Rubin]

ste...@mpeforth.com (Stephen Pelc) writes:
> The Lite compiler is ideal for hobbyists who do not require a
> huge amount of optimised code. There is an upgrade path to the
> inexpensive Stamp compiler.

I'd agree with this if the hobbyist's goal is to get some gadget working
using Forth as a development tool like an oscilloscope, whose internals
they don't really care about. If their interest is in language
implementations and Forth hacking per se, obviously not having source
code is a big drawback.

> Even the Lite compiler comes with full source code for the target.

Does that include the target-resident interpreter that will run on
Juergen's board? I can understand if it doesnt, but it becomes a lot
more interesting if it does.

>> and a NDA is not the right choice for FOSS freaks.
> That's just politics and a different business model.

Agree.

> In the Forth world, if you want good code quality from a
> production-grade compiler, you have to use a commercial one.

From seeing the huge Arduino world based around the AVR8 when they could
perfectly well be using Cortex M processors, I have to infer that code
speed (and therefore compiler optimizations) just plain don't matter for
a lot of embedded applications. So from that perspective, I'd say the
attractions of VFX compared to something like Mecrisp are

1) language features and libraries
2) umbilical debugging; and
3) optimizing compiler

in about that order, maybe with 1 and 2 switched. I do think you'd
generate considerable interest in VFX Lite if you did an AVR target. I
wonder if the introduction of the MSP432 (a Cortex M0 core with
MSP430-like marketing) means TI now sees the MSP430 as a dead end. But
the AVR is still going strong.

[JUERGEN]

On Monday, July 20, 2015 at 10:56:24 AM UTC+1, Matthias Koch wrote:
> I am a physicist and very curious on how it works internally. I simply would not recommend VFX for the hobbyist or the one who wishes to play with Forth internals. The in-target Lite compilers have their limits, and a NDA is not the right choice for FOSS freaks. The original question has been about Arduino Due, so I assumed an experimental environment.
>
> Matthias

Another very negative Forth post. Wanting all the internals for free - Want the IP without paying for it.
Is this how physicists work? Along your lines I could not recommend Mecrisp, as it is a freebe and you cannot spend the time to support it professionally, as you are not paid for it - or you do not have a job or you use your time at this job for maintaining your product?
Facts do not change except you are a genius.
I actually had many discussions with Stephen and in the end MPE agreed to do the LITE versions. A slightly downgraded version from the professional products, but at least a fork from a professional product. And having started with it you can move easily to the more complex professional versions. Rather than starting with X and then change from 0 to a professional version.
AND HEY, NEXT WEEK up to 1024 scouts will somehow solder a MicroBox and play with VFX LITE programmed onto the MSP430 chips - not with one of the free versions where they, like the physicist, might want to look at all the internal bits - and they would not be interested, except if they reach a higher level in Forth. Or even better if they like the Language.
Professional products need the money paid to survive. Otherwise Mecrisp might be the most professional level?
As you probably know better than I do, there is not much professional product left in the Forth world.
If you are a good physicist and want to understand it all - write your own compiler as you did - is it for professional work, hobbyists or just to play around with ?
Define the target audience and then the product according to it.
Sorry but you really stepped onto my toes with your post.

[Stephen Pelc]

On Mon, 20 Jul 2015 11:48:35 -0700, Paul Rubin
<no.e...@nospam.invalid> wrote:

>> Even the Lite compiler comes with full source code for the target.
>
>Does that include the target-resident interpreter that will run on
>Juergen's board? I can understand if it doesnt, but it becomes a lot
>more interesting if it does.

That's what I just said, so yes.

>From seeing the huge Arduino world based around the AVR8 when they could
>perfectly well be using Cortex M processors, I have to infer that code
>speed (and therefore compiler optimizations) just plain don't matter for
>a lot of embedded applications. So from that perspective, I'd say the
>attractions of VFX compared to something like Mecrisp are
>
> 1) language features and libraries
> 2) umbilical debugging; and
> 3) optimizing compiler
>
>in about that order, maybe with 1 and 2 switched. I do think you'd
>generate considerable interest in VFX Lite if you did an AVR target.

If code speed doesn't matter, use a Linux system to soak up all
those free cycles. It's interesting that a Raspberry Pi is cheaper
than an Arduino.

Being able to write interrupt handlers in high-level is the killer
item for any high-level language. I haven't written an ARM/Cortex
ISR in assembler for 10-15 years except to prove that I still
know how.

The AVR only has three address registers. That's good enough for C's
single frame stack, but not for Forth. A Cortex-M0 makes a far
better Forth engine than an AVR ... and is probably cheaper.
We had an AVR target for while - it was swept aside by ARM.

[Anton Ertl]

ste...@mpeforth.com (Stephen Pelc) writes:
>On Mon, 20 Jul 2015 11:57:46 +0200, Matthias Koch
><matthi...@hot.uni-hannover.de> wrote:
>
>>I am a physicist and very curious on how it works internally.

You could look at http://www.complang.tuwien.ac.at/forth/flk.1.3.tar.gz

>The internals are described in EuroForth papers.

Internals of VFX? Which papers?

If you are interested in general papers about the "analytical" approach
to Forth native code compilation, you could start at
<http://www.complang.tuwien.ac.at/projects/rafts.html>

- anton
--
M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
New standard: http://www.forth200x.org/forth200x.html
EuroForth 2015: http://www.mpeforth.com/euroforth2015/euroforth2015.htm

[Paul Rubin]

ste...@mpeforth.com (Stephen Pelc) writes:
>>> Even the Lite compiler comes with full source code for the target.
>>Does that include the target-resident interpreter

> That's what I just said, so yes.

Oh neat, thanks! Is there a url where I can download it? I had
expected "compiler" was a cross-compiler where "source code for the
target" meant an address interpreter that would run headless code sent
by the closed-source compiler. The text interpreter running on the
target sounded different so I had to ask for clarification.

> If code speed doesn't matter, use a Linux system to soak up all
> those free cycles. It's interesting that a Raspberry Pi is cheaper
> than an Arduino.

There are some expensive Arduinos but the entry level ones are much
cheaper than an RPi, plus they are way smaller and use much less power.
If you include the sub-Arduinos based on the ATTiny85, some of them are
really small and cheap:

https://www.olimex.com/Products/Duino/AVR/OLIMEXINO-85S/
http://digistump.com/products/1

They are too small (8k flash) to run a good resident Forth, but it would
be really cool to support them with a cross compiler.

> Being able to write interrupt handlers in high-level is the killer
> item for any high-level language. I haven't written an ARM/Cortex ISR
> in assembler for 10-15 years except to prove that I still know how.

Hmm, I guess that could be an issue for some things. But even on an 8
Mhz part (the 5 volt AVR's are 12-16 mhz) you can usually afford a few
microseconds per interrupt, which is enough to run a bit of threaded
interpreted Forth code.

> The AVR only has three address registers. That's good enough for C's
> single frame stack, but not for Forth.

I'm not sure but I thought the AVR had a hardware stack pointer that
(like the program counter) is independent of the general purpose
registers. So with subroutine threading you don't need an address
register (pair) for the R stack. You can relative CALL to an address
within 2k words of the current pc in one 16-bit instruction word, which
should work out nicely for a small Forth. I haven't looked at Amforth
though.

> A Cortex-M0 makes a far better Forth engine than an AVR ... and is
> probably cheaper. We had an AVR target for while - it was swept aside
> by ARM.

The AVR has its good points including the PDIP-packaged (breadboard
friendly) Atmega328 having >2x more capacity than the MSP430G2553 while
costing around the same. There aren't many PDIP ARM's. Plus the AVR
can drive quite a lot of current from its gpio pins, enough to run stuff
like relays and leds. Hardware guys tell me features like this keep the
AVR attractive. I get the impression that ARMs are harder to program at
the low level, but I haven't tried it yet.

[Stephen Pelc]

On Tue, 21 Jul 2015 00:32:32 -0700, Paul Rubin
<no.e...@nospam.invalid> wrote:

>Oh neat, thanks! Is there a url where I can download it?

Of course - try our web site.

http://lmgtfy.com/?q=mpe+lite+cross+compiler

[Stephen Pelc]

On Tue, 21 Jul 2015 05:18:55 GMT, an...@mips.complang.tuwien.ac.at
(Anton Ertl) wrote:

>>The internals are described in EuroForth papers.
>
>Internals of VFX? Which papers?

http://www.mpeforth.com/arena.htm

[Paul Rubin]

ste...@mpeforth.com (Stephen Pelc) writes:
>>Oh neat, thanks! Is there a url where I can download it?
> Of course - try our web site.
> http://lmgtfy.com/?q=mpe+lite+cross+compiler

I did look at that page (http://www.mpeforth.com/xc7lite.htm), but as it
says at the top, it's about a cross compiler. I'm asking about a
resident text interpreter that runs directly on the MSP430, like 4e4th.
Not a cross compiler. Are you distributing something like that in
source code form? I don't see any clear mention of that on your Lite
cross compiler page or in the linked doc files. And then there's the
matter of how to bootstrap it.

The download that I see on that page is a Windows .exe that I have no
way to run or unpack.

[Stephen Pelc]

On Mon, 20 Jul 2015 10:42:30 -0700 (PDT), Gary Bergstrom
<forth...@gmail.com> wrote:

>On Monday, July 20, 2015 at 8:37:42 AM UTC-4, Stephen Pelc wrote:
>...

>> The internals are described in EuroForth papers. The real problems for
>> people who want to write good compilers are that
>> a) Pattern matching (Timbre style) compilers are a dead end in
>> terms of ultimate code quality.
>> b) Analytical compilers take a lot of effort to write and take a
>> while to mature.

>I'll take some exception to part a). As a casual statement it is, of cours=
>e, true. By definition peephole optimizers have limited breadth in their s=
>cope but that doesn't mean that they should be dismissed.
...
>A lot has to do with how you write the Forth source code. Small definition=
>s lend themselves to peephole compilation quite nicely.

I may have been a bit cruel. It is certainly true that on small and
irregular CPUs, pattern matchers can do a useful job. With enough
effort, you can do a reasonable job. However, the rule base size
becomes a problem after a while. Analytical compilers require much
more structure to begin with, but take you further in the long term.

A typical VFX code generator requires an assembler, adisassembler, and
5000-6000 lines of Forth for the code generator itself. Of those
5000-6000 lines, about half is reusable for the next target.

>The most "fun" I had was porting to a tiny 'hc08. An 8 bit Forth that ran =
>multitasking on a part with 2k of flash and 128 bytes of RAM. On such a sm=
>all part the port only took a day or too. =20
>
>But porting to every new processor gets old. I recently bought a license t=
>o VFX for Cortex parts and I'm happy with it. There is room for both.

It's processors like the HC08/RS08 where a pattern matcher does well.

[Paul Rubin]

JUERGEN <epld...@aol.com> writes:
> On Monday, July 20, 2015 at 10:56:24 AM UTC+1, Matthias Koch wrote:
>> I am a physicist and very curious on how it works internally. I
>> simply would not recommend VFX for the hobbyist or the one who
>> wishes to play with Forth internals. The in-target Lite compilers
>> have their limits, and a NDA is not the right choice for FOSS freaks.

> Another very negative Forth post. Wanting all the internals for free -
> Want the IP without paying for it. Is this how physicists work?

I didn't see it as a negative post, and I do note that Matthias is
giving away Mecrisp. I don't think he said anything bad about VFX or
asked anything from its vendor. He suggested that a FOSS implementation
(like his) has advantages for certain types of users. And he put the
work into writing such an implementation, which deserves respect.

> Along your lines I could not recommend Mecrisp, as it is a freebe and
> you cannot spend the time to support it professionally, as you are not
> paid for it

I would hope that Stephen has better things to do than offer unpaid
professional support to those 1024 Scouts who will be using the gratis
Lite product. I'd also note that historically, the dominant Forth
implementation among hobbyists was probably FIGForth, which was free.
The commercial implementations were better but they weren't easily
affordable for non-professionals. Forth would probably be dead today
rather than merely obscure, if FIGForth hadn't popularized it as it did.
If you used FIGForth yourself, you probably got something out of it.

Finally if I'm reading Stephen's posts correctly, the Lite resident
interpreter is actually distributed as source, which is great if it's
true, especially if it can be compiled with the Lite cross-compiler.
That means users can study and modify the interpreter, which is
important.

> 1024 scouts will somehow solder a MicroBox and play with VFX LITE
> programmed onto the MSP430 chips - not with one of the free versions
> where they, like the physicist, might want to look at all the internal
> bits - and they would not be interested, except if they reach a higher
> level in Forth. Or even better if they like the Language.

Time will tell, but you may be underestimating how interested these
Scouts are likely to be in seeing the internal bits.

> Professional products need the money paid to survive. Otherwise
> Mecrisp might be the most professional level? As you probably know
> better than I do, there is not much professional product left in the
> Forth world. If you are a good physicist and want to understand it
> all - write your own compiler as you did - is it for professional
> work, hobbyists or just to play around with ? Define the target
> audience and then the product according to it.

I think Rickman is trying to use Mecrisp professionally. I'd certainly
count the 1024 scouts as mostly hobbyist-level rather than
professionals. I myself have tried out a few different Linux desktop
Forths, and so far Gforth (which is free) is the one that works best for
me so far. VFX and Swift have huge advantages for cross-development and
I'd definitely consider them if I got involved in an embedded Forth
project, but haven't felt the need so far.

I'll note that I got paid for a while to work on GCC, which is a free
compiler (non-Forth) used by many professionals. As Stephen says, it's
just a different business model.

[visua...@rocketmail.com]

On Monday, July 20, 2015 at 5:02:36 PM UTC-4, JUERGEN wrote:
> On Monday, July 20, 2015 at 10:56:24 AM UTC+1, Matthias Koch wrote:
> > I am a physicist and very curious on how it works internally. I simply would not recommend VFX for the hobbyist or the one who wishes to play with Forth internals. The in-target Lite compilers have their limits, and a NDA is not the right choice for FOSS freaks. The original question has been about Arduino Due, so I assumed an experimental environment.
> >
> > Matthias
>
> Another very negative Forth post. Wanting all the internals for free - Want the IP without paying for it.
> Is this how physicists work? Along your lines I could not recommend Mecrisp, as it is a freebe and you cannot spend the time to support it professionally, as you are not paid for it - or you do not have a job or you use your time at this job for maintaining your product?
> Facts do not change except you are a genius.

Matthias is a genius!

DB.

[Bernd Paysan]

JUERGEN wrote:

> On Monday, July 20, 2015 at 10:56:24 AM UTC+1, Matthias Koch wrote:
>> I am a physicist and very curious on how it works internally. I simply
>> would not recommend VFX for the hobbyist or the one who wishes to play
>> with Forth internals. The in-target Lite compilers have their limits, and
>> a NDA is not the right choice for FOSS freaks. The original question has
>> been about Arduino Due, so I assumed an experimental environment.
>>
>> Matthias
>
> Another very negative Forth post. Wanting all the internals for free -
> Want the IP without paying for it.

Jürgen, *every* scientist works like this. Publish your stuff, don't hide
it. That's what has advanced science for the last 400 years (and during the
greek era of science).

In any case: support is a very well-working business model for free
software. If you want the software including all sources and tinker with
it, you get it. If you want professional support, you pay for it. That is
a multi-billion dollar market now, free software support.

The downside of it is that if the incentive is to answer support questions,
the code becomes more difficult to understand and tinker with it, and more
buggy (because then you'll have more support questions). GCC, the first
free software program that was turned into such a support-oriented business,
shows that setting a certain incentive makes the result predictable. Pay
for good support makes it more likely that the quality goes down.

I don't think you understand anything about free software. First of all, it
is *not* supposed to mean "free" as in "free beer". That's just a side
effect that when free software already exists, you can copy it for free.

--
Bernd Paysan
"If you want it done right, you have to do it yourself"
net2o ID: kQusJzA;7*?t=uy@X}1GWr!+0qqp_Cn176t4(dQ*
http://bernd-paysan.de/

[JUERGEN]

Bernd, if you want to lecture me, do it on a private basis you do have my email. This would be appreciated. Here on this forum it looks pretty arrogant and I do not appreciate it.
I have made my point and I stick to it. There is no NDA with VFX LITE. If this is not good enough, I assume there was never a communication of getting access to more of VFX for a scientific project. At least I am not aware of it.
So my opinion about negative is correct. Actually I have to correct myself, a negative comment about MPE which does not hold water.

[hughag...@gmail.com]

On Monday, July 20, 2015 at 3:53:22 PM UTC-7, Stephen Pelc wrote:
> On Mon, 20 Jul 2015 11:48:35 -0700, Paul Rubin
> <no.e...@nospam.invalid> wrote:
>
> >> Even the Lite compiler comes with full source code for the target.

I don't blame Stephen Pelc for wanting to get paid, and for wanting to avoid getting ripped off --- so, holding onto the source-code or at least requiring an NDA is reasonable.

At Testra they had a different strategy. They built their own processor (the MiniForth, now called RACE). They make their money by selling motion-control boards and processor chips. I don't know that they have ever sold any chips by themselves, as they seem to sell only boards. The point though, is that they sell hardware not software. My MFX is given away for free --- it is only useful for generating code for the MiniForth/RACE so it can't be used to compete against Testra --- any use of it will necessarily require the user to buy chips or boards, and there is only one source for this.

> The AVR only has three address registers. That's good enough for C's
> single frame stack, but not for Forth. A Cortex-M0 makes a far
> better Forth engine than an AVR ... and is probably cheaper.
> We had an AVR target for while - it was swept aside by ARM.

I like the AVR. It does have only the X Y and Z register-pairs that can be used as pointers, but I don't see this as a big problem. Moving one register-pair into another is a one-cycle instruction --- so, just leave Z available as a general-purpose pointer and move your pointer into it as necessary.

The AVR code tends to be rather bloated. Also, the AVR lacks certain features that would improve both speed and size significantly. It is almost 20 years old, and it is the last 8-bit processor that is still a realistic target for Forth --- it is true that the ARM is the modern way, and the AVR is pretty retro.

Writing a compiler for either the AVR or the ARM or any other such processor is a waste of time --- it will get pirated if the source-code is made available, whether there is an NDA or not --- and, nobody will use it if the source-code is not available because they don't want to depend upon somebody else to support it, as that person may prove to be unreliable (highly likely, as there is no money to be made, and it is really just a hobby).

This is why I'm promoting the FMITE nowadays --- the only way to make money is with a custom processor --- that is what Testra did with the MiniForth/RACE and what I would like to do with the FMITE.