Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.forth > #38115 > unrolled thread
| Started by | lehs <skydda.barnen@gmail.com> |
|---|---|
| First post | 2015-04-11 01:16 -0700 |
| Last post | 2015-04-30 02:35 -0700 |
| Articles | 20 on this page of 169 — 23 participants |
Back to article view | Back to comp.lang.forth
How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-11 01:16 -0700
Re: How efficient are locals? How portable? stephen@mpeforth.com (Stephen Pelc) - 2015-04-11 15:56 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-11 15:48 -0700
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-11 17:43 -0700
Re: How efficient are locals? How portable? "HAA" <someone@microsoft.com> - 2015-04-14 18:40 +1000
Re: How efficient are locals? How portable? empty-buffers <empty.buffersYOU-DONT-WANT-THIS@gmail.NEITHER-THIS.com> - 2015-04-22 19:23 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-22 13:28 -0700
Re: How efficient are locals? How portable? empty-buffers <empty.buffersYOU-DONT-WANT-THIS@gmail.NEITHER-THIS.com> - 2015-04-22 22:29 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-22 16:01 -0700
Re: How efficient are locals? How portable? empty-buffers <empty.buffersYOU-DONT-WANT-THIS@gmail.NEITHER-THIS.com> - 2015-04-22 23:20 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-23 00:28 -0700
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-23 02:30 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-23 09:57 +0000
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-23 11:28 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-23 09:31 -0400
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-23 13:32 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-23 10:56 -0700
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-23 11:12 -0700
Re: How efficient are locals? How portable? Coos Haak <chforth@hccnet.nl> - 2015-04-23 22:44 +0200
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-23 23:24 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-24 09:21 +0000
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-24 11:44 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-24 08:35 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-24 15:40 +0000
Re: How efficient are locals? How portable? mhx@iae.nl - 2015-04-24 10:28 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-24 17:43 +0000
Re: How efficient are locals? How portable? mhx@iae.nl - 2015-04-24 22:44 -0700
Re: How efficient are locals? How portable? empty-buffers <empty.buffersYOU-DONT-WANT-THIS@gmail.NEITHER-THIS.com> - 2015-04-24 15:00 +0000
Re: How efficient are locals? How portable? Paul Rubin <no.email@nospam.invalid> - 2015-04-24 09:07 -0700
Re: How efficient are locals? How portable? Raimond Dragomir <raimond.dragomir@gmail.com> - 2015-04-23 07:30 -0700
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-23 11:02 -0400
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-23 16:30 +0100
Re: How efficient are locals? How portable? Raimond Dragomir <raimond.dragomir@gmail.com> - 2015-04-23 09:38 -0700
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-24 15:57 +0100
Re: How efficient are locals? How portable? empty-buffers <empty.buffersYOU-DONT-WANT-THIS@gmail.NEITHER-THIS.com> - 2015-04-24 15:14 +0000
Re: How efficient are locals? How portable? rickman <gnuarm@gmail.com> - 2015-04-23 06:58 -0400
Re: How efficient are locals? How portable? Coos Haak <chforth@hccnet.nl> - 2015-04-23 14:47 +0200
Re: How efficient are locals? How portable? "Elizabeth D. Rather" <erather@forth.com> - 2015-04-23 08:34 -1000
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-13 12:32 +0000
Re: How efficient are locals? How portable? rickman <gnuarm@gmail.com> - 2015-04-13 21:57 -0400
Re: How efficient are locals? How portable? Paul Rubin <no.email@nospam.invalid> - 2015-04-13 19:25 -0700
Re: How efficient are locals? How portable? Mark Wills <markwills1970@gmail.com> - 2015-04-14 01:43 -0700
Re: How efficient are locals? How portable? Mark Wills <markwills1970@gmail.com> - 2015-04-14 01:45 -0700
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-14 10:12 -0700
Re: How efficient are locals? How portable? Mark Wills <markwills1970@gmail.com> - 2015-04-14 13:09 -0700
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-15 14:18 -0700
Re: How efficient are locals? How portable? Raimond Dragomir <raimond.dragomir@gmail.com> - 2015-04-15 22:13 -0700
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-15 23:14 -0700
Re: How efficient are locals? How portable? Mark Wills <markwills1970@gmail.com> - 2015-04-16 01:12 -0700
Re: How efficient are locals? How portable? Mark Wills <markwills1970@gmail.com> - 2015-04-16 01:23 -0700
Re: How efficient are locals? How portable? rickman <gnuarm@gmail.com> - 2015-04-16 14:28 -0400
Re: How efficient are locals? How portable? rickman <gnuarm@gmail.com> - 2015-04-16 14:37 -0400
Re: How efficient are locals? How portable? Mark Wills <markwills1970@gmail.com> - 2015-04-17 04:43 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-14 14:53 +0000
Re: How efficient are locals? How portable? Julian Fondren <julian.fondren@gmail.com> - 2015-04-16 00:34 -0700
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-16 00:54 -0700
Re: How efficient are locals? How portable? Julian Fondren <julian.fondren@gmail.com> - 2015-04-16 01:07 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-16 12:22 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-16 08:32 -0700
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-16 20:42 -0700
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-17 00:14 -0400
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-16 22:14 -0700
Re: How efficient are locals? How portable? Bernd Linsel <bl1@gmx.com> - 2015-04-17 17:43 +0200
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-17 20:46 +0000
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-18 06:54 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-18 06:52 -0400
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-18 22:14 -0700
Re: How efficient are locals? How portable? "WJ" <w_a_x_man@yahoo.com> - 2015-04-19 08:46 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-19 06:04 -0400
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-19 10:12 +0000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-19 10:43 -0700
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-19 16:28 -0400
Re: How efficient are locals? How portable? franck.bensusan@gmail.com - 2015-04-19 15:35 -0700
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-19 19:14 -0400
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-19 16:48 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-20 09:51 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-20 06:27 -0400
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-20 13:04 +0000
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-20 14:09 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-21 07:17 -0400
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-21 16:50 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-21 16:35 -0400
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-22 06:13 -0400
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-22 06:23 -0400
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-21 17:18 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-21 16:38 -0400
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-22 10:12 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-22 06:26 -0400
Re: How efficient are locals? How portable? "Elizabeth D. Rather" <erather@forth.com> - 2015-04-20 08:46 -1000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-20 23:02 -0700
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-21 06:35 -0400
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-21 06:41 -0400
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-20 10:22 +0000
Re: How efficient are locals? How portable? franck.bensusan@gmail.com - 2015-04-20 23:28 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-21 11:03 +0000
Re: How efficient are locals? How portable? franck.bensusan@gmail.com - 2015-04-21 07:20 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-22 15:35 +0000
Re: How efficient are locals? How portable? franck.bensusan@gmail.com - 2015-04-23 10:55 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-24 07:15 +0000
Re: How efficient are locals? How portable? Bernd Linsel <bl1@gmx.com> - 2015-04-20 17:52 +0200
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-20 09:03 -0700
Re: How efficient are locals? How portable? Lars Brinkhoff <lars.spam@nocrew.org> - 2015-04-22 08:33 +0200
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-22 02:20 -0700
Re: How efficient are locals? How portable? Lars Brinkhoff <lars.spam@nocrew.org> - 2015-04-22 11:35 +0200
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-20 17:50 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-17 01:45 -0700
Re: How efficient are locals? How portable? Raimond Dragomir <raimond.dragomir@gmail.com> - 2015-04-17 02:37 -0700
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-17 10:14 +0000
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-17 10:18 +0000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-17 09:38 -0700
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-17 21:25 +0100
Re: How efficient are locals? How portable? "WJ" <w_a_x_man@yahoo.com> - 2015-04-18 07:51 +0000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-19 08:45 -0700
Re: How efficient are locals? How portable? stephen@mpeforth.com (Stephen Pelc) - 2015-04-19 16:24 +0000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-19 09:58 -0700
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-19 19:00 +0100
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-19 12:27 -0700
Re: How efficient are locals? How portable? stephen@mpeforth.com (Stephen Pelc) - 2015-04-19 19:42 +0000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-19 13:49 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-20 09:39 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-19 17:59 -0400
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-19 16:39 -0700
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-20 04:58 -0400
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-20 08:52 -0700
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-20 18:04 +0100
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-20 19:05 +0100
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-24 10:06 -0700
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-24 19:18 +0100
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-24 11:43 -0700
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-24 22:03 +0100
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-26 20:05 +0100
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-26 21:05 +0000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-26 15:08 -0700
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-27 00:17 +0000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-27 03:55 -0400
Re: How efficient are locals? How portable? "Elizabeth D. Rather" <erather@forth.com> - 2015-04-26 22:25 -1000
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-29 08:53 -0400
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-29 09:35 -0700
Re: How efficient are locals? How portable? mhx@iae.nl - 2015-04-29 10:14 -0700
Re: How efficient are locals? How portable? "Elizabeth D. Rather" <erather@forth.com> - 2015-04-29 09:00 -1000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-29 13:22 -0700
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-05-10 22:50 -0700
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-05-10 22:53 -0700
Re: How efficient are locals? How portable? "Rod Pemberton" <bork@lllljunkqwer.cpm> - 2015-04-26 23:04 -0400
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-26 20:51 -0700
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-27 09:38 +0000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-27 23:18 -0700
Re: How efficient are locals? How portable? "Rod Pemberton" <bork@lllljunkqwer.cpm> - 2015-04-28 03:19 -0400
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-27 12:33 +0100
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-27 23:31 -0700
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-28 08:07 +0100
Re: How efficient are locals? How portable? Lars Brinkhoff <lars.spam@nocrew.org> - 2015-04-28 10:20 +0200
Re: How efficient are locals? How portable? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2015-04-28 12:17 +0100
Re: How efficient are locals? How portable? Lars Brinkhoff <lars.spam@nocrew.org> - 2015-04-28 14:04 +0200
Re: How efficient are locals? How portable? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2015-04-28 14:49 +0100
Re: How efficient are locals? How portable? "Alex McDonald" <blog@rivadpm.com> - 2015-04-28 22:56 +0100
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-20 23:22 -0700
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-17 13:44 -0700
Re: How efficient are locals? How portable? Coos Haak <chforth@hccnet.nl> - 2015-04-18 00:31 +0200
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-18 14:22 +0000
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-18 22:51 -0700
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-19 01:25 -0700
Re: How efficient are locals? How portable? Coos Haak <chforth@hccnet.nl> - 2015-04-19 21:12 +0200
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-19 12:56 -0700
Re: How efficient are locals? How portable? Doug Hoffman <glidedog@gmail.com> - 2015-04-19 17:53 -0400
Re: How efficient are locals? How portable? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2015-04-20 11:59 +0000
Re: How efficient are locals? How portable? albert@spenarnc.xs4all.nl (Albert van der Horst) - 2015-04-27 00:33 +0000
Re: How efficient are locals? How portable? hughaguilar96@gmail.com - 2015-04-19 08:31 -0700
Re: How efficient are locals? How portable? lehs <skydda.barnen@gmail.com> - 2015-04-30 02:35 -0700
Page 6 of 9 — ← Prev page 1 2 3 4 5 [6] 7 8 9 Next page →
| From | hughaguilar96@gmail.com |
|---|---|
| Date | 2015-04-20 09:03 -0700 |
| Message-ID | <25ad4bb1-3baa-4fbb-af0b-28353d666d69@googlegroups.com> |
| In reply to | #38417 |
On Monday, April 20, 2015 at 8:52:04 AM UTC-7, Bernd Linsel wrote:
> Am 19.04.2015 um 19:43 schrieb hughaguilar96@gmail.com:
> > On Thursday, April 16, 2015 at 9:14:20 PM UTC-7, Doug Hoffman wrote:
> >> Many, including me, are still using { ... } for locals and may never stop.
> >
> > In Forth-200x the { is not defined as anything, so it is legal to use { for anything that you want, including locals. VFX has both { and {: for locals, so the programmer can use either one. There is 20+ years of legacy code using { for locals that will use { until it gets manually converted to use {: instead (a good job for an unpaid intern to do, as no company has money to pay a programmer to do such a tedious task). OTOH, Forth-200x loyalists will write new programs using {: because that is what Anton Ertl is encouraging them to do.
> my unpaid intern is called Pearl or awk:
>
> s/\s+\{\s+/\{:/g s/\s+\}\s+/:\}/g
As you are skilled at regular-expressions, how about a script that changes this:
{ ... }
into this:
char & comment ... &
Give that to Forth Inc. with my regards --- they can change all of their legacy code that uses { ... } for multi-line comments over to my COMMENT --- then the rest of the Forth community can go on using { ... } for local definitions, just like they have been since before ANS-Forth existed. :-)
[toc] | [prev] | [next] | [standalone]
| From | Lars Brinkhoff <lars.spam@nocrew.org> |
|---|---|
| Date | 2015-04-22 08:33 +0200 |
| Message-ID | <86sibsised.fsf@vps34351.public.cloudvps.com> |
| In reply to | #38418 |
hughaguilar96@gmail.com writes:
> Give that to Forth Inc. with my regards --- they can change all of
> their legacy code that uses { ... } for multi-line comments over to my
> COMMENT --- then the rest of the Forth community can go on using {
> ... } for local definitions, just like they have been since before
> ANS-Forth existed. :-)
There's this:
"Nice Locals" by Wil Baden.
http://www.wilbaden.com/neil_bawd/niceloc.txt
[toc] | [prev] | [next] | [standalone]
| From | lehs <skydda.barnen@gmail.com> |
|---|---|
| Date | 2015-04-22 02:20 -0700 |
| Message-ID | <81aa146c-95e6-455e-8f9f-e5e91332fba6@googlegroups.com> |
| In reply to | #38475 |
Den onsdag 22 april 2015 kl. 08:33:32 UTC+2 skrev Lars Brinkhoff:
> hughaguilar96@gmail.com writes:
> > Give that to Forth Inc. with my regards --- they can change all of
> > their legacy code that uses { ... } for multi-line comments over to my
> > COMMENT --- then the rest of the Forth community can go on using {
> > ... } for local definitions, just like they have been since before
> > ANS-Forth existed. :-)
>
> There's this:
>
> "Nice Locals" by Wil Baden.
> http://www.wilbaden.com/neil_bawd/niceloc.txt
Isn't that so? Everything is possible to solve in Forth!
(BTW, I don't know how to use GitHub. Are there a short intro?)
[toc] | [prev] | [next] | [standalone]
| From | Lars Brinkhoff <lars.spam@nocrew.org> |
|---|---|
| Date | 2015-04-22 11:35 +0200 |
| Message-ID | <867ft4ijyc.fsf@vps34351.public.cloudvps.com> |
| In reply to | #38477 |
lehs <skydda.barnen@gmail.com> writes: >> "Nice Locals" by Wil Baden. >> http://www.wilbaden.com/neil_bawd/niceloc.txt > Isn't that so? Everything is possible to solve in Forth! Not a 100% solution, of course. > BTW, I don't know how to use GitHub. Are there a short intro? I'm guessing this is a good starting point: http://help.github.com/articles/good-resources-for-learning-git-and-github/
[toc] | [prev] | [next] | [standalone]
| From | albert@spenarnc.xs4all.nl (Albert van der Horst) |
|---|---|
| Date | 2015-04-20 17:50 +0000 |
| Message-ID | <55353c5f$0$21339$e4fe514c@dreader37.news.xs4all.nl> |
| In reply to | #38417 |
In article <mh37b3$n96$1@newsreader4.netcologne.de>,
Bernd Linsel <bl1@gmx.com> wrote:
>Am 19.04.2015 um 19:43 schrieb hughaguilar96@gmail.com:
>> On Thursday, April 16, 2015 at 9:14:20 PM UTC-7, Doug Hoffman wrote:
>>> Many, including me, are still using { ... } for locals and may never stop.
>>
>> In Forth-200x the { is not defined as anything, so it is legal to use
>{ for anything that you want, including locals. VFX has both { and {:
>for locals, so the programmer can use either one. There is 20+ years of
>legacy code using { for locals that will use { until it gets manually
>converted to use {: instead (a good job for an unpaid intern to do, as
>no company has money to pay a programmer to do such a tedious task).
>OTOH, Forth-200x loyalists will write new programs using {: because that
>is what Anton Ertl is encouraging them to do.
>>
>> SwiftForth uses { for multi-line comments. So, if any of that legacy
>code from 20+ years that uses { for locals is compiled under SwiftForth,
>it will fail to compile because the local definitions will be commented
>out, and any reference to the local will not work --- you will either
>get a confusing error message at compile-time, or possibly a program
>that compiles but doesn't work correctly at run-time. When this happens,
>Elizabeth Rather will tell you that you have a bug in your program, and
>you just aren't any good at Forth --- so you have to take time to debug
>your previously-working program that you likely haven't looked at in
>years or decades --- eventually you figure out what the problem is, and
>so you manually convert all of your { into {: for your locals.
>>
>> This is the chronic problem in ANS-Forth. The standard had a lot of
>"may or may not" statements. For example, the control-flow stack may or
>may not be the same as the data-stack. The result is that the programmer
>has to figure out what is the worst-case scenario (that the control-flow
>stack is the data-stack) and write his code with this assumption in
>order for his code to be portable. If you assume that the control-flow
>stack is distinct from the data-stack, your code is not going to work on
>SwiftForth --- when this happens, Elizabeth Rather will tell you that
>there is a bug in your program, and you just aren't any good at Forth.
>>
>> The ultimate effect of the ANS-Forth standard is that everybody is
>dragged down to the level of SwiftForth --- SwiftForth effectively is
>the standard, even though programming in a way that makes sense is
>theoretically allowed --- even people using other compilers have to
>limit themselves as if they were using SwiftForth, in order to have an
>ANS-Forth compliant program.
>>
>> This is what I said previously about entropy: "If you have a barrel of
>wine, and you pour a cup of sewage into it, the result is a barrel of
>sewage." SwiftForth is the cup of sewage that causes all Forth
>programming to be sewage, or to be non-standard.
>>
>
>my unpaid intern is called Pearl or awk:
>
>s/\s+\{\s+/\{:/g s/\s+\}\s+/:\}/g
>
>
My assistant is called ``refilter'' a regexp filter written in Forth
\ -------------8<---------------
#!/home/albert/bin/refilter -s
1 ARG[] GET-FILE
"<{>" "{:" GLOBAL
"<}>" ":}" GLOBAL
1 ARG[] PUT-FILE
\ -------------8<---------------
Undoubtedly Hugh has something like that in his novice package.
Groetjes Albert
--
Albert van der Horst, UTRECHT,THE NETHERLANDS
Economic growth -- being exponential -- ultimately falters.
albert@spe&ar&c.xs4all.nl &=n http://home.hccnet.nl/a.w.m.van.der.horst
[toc] | [prev] | [next] | [standalone]
| From | lehs <skydda.barnen@gmail.com> |
|---|---|
| Date | 2015-04-17 01:45 -0700 |
| Message-ID | <3002c8b9-c725-4857-a003-4b5c0dbc36d9@googlegroups.com> |
| In reply to | #38252 |
Den fredag 17 april 2015 kl. 05:42:57 UTC+2 skrev hughag...@gmail.com:
> On Thursday, April 16, 2015 at 8:32:43 AM UTC-7, lehs wrote:
> > Den torsdag 16 april 2015 kl. 15:40:37 UTC+2 skrev Anton Ertl:
> > > While not every system supports the Forth-2012 locals syntax {: ... :}
> > > out of the box yet, you can add this syntax yourself easily by
> > > downloading and unzipping
> > >
> > > http://www.forth200x.org/forth200x-code.zip
>
> > Thanks for the zip file! I might use this locals as a standard extension for programs intended to be portable.
>
> Anton's implementation has a bug in it. It initializes the locals right of | to whatever garbage value was in memory previously. If the user forgets to explicitly initialize these locals, his program will behave differently every time that it is run --- this lack of deterministic behavior will make the bug difficult to find.
>
> By comparison, my implementation in the novice package (http://www.forth.org/novice.html) initializes the local right of | to zero. If the programmer forgets to explicitly initialize them, he will discover his bug much more easily.
>
> Another problem with Anton Ertl's implementation is that he uses {: as the word that begins defining the locals. For over 20 years, since prior to ANS-Forth, everybody in the Forth community has used { for this (this is called the John Hopkins Format because that is where it originated about a quarter of a century ago). Anton pulled the rug out from under a huge amount of legacy code with his name change. The reason why he did this, is because SwiftForth uses { for multi-line comments, and he can't contradict Forth Inc. or they will remove him from the Forth-200x committee --- so he betrays the entire Forth community instead.
It's old Fortran style not to initialize. I agree that initializing is better but I'm glad that ALLOCATE doesn't.
I will look at your implementation too. Any fast code could be used if included, but then it seems to be an advantage with "odd" names to avoid redefining words in the actual system.
For my own purposes, my own idea with a number of extra stacks like
07FF ALLOCATE THROW CONSTANT xst
: >x ( x -- ) CELL xst +! xst @ ! ;
: x> ( -- x ) xst @ @ -CELL xst +! ;
: x@ ( -- x ) xst @ @ ;
: x! ( n -- ) xst @ ! ;
: x+! ( n -- ) xst @ +! ;
works alright, to keep the parameters in track. While allocating 0 >x, x@ x! x+! could be used as locals. And sometimes an extra stack is handy as such.
But what I like with Mark Wills idea
: OpenSerialPort ( structaddr -- flag )
locals{ struct baudRate parity startBit stopBit }
set struct \ structaddr to struct (address of struct)
struct @ set baudRate
struct 1 cells + @ set parity
struct 2 cells + @ set startBit
struct 3 cells + @ set stopBit
baudRate 1200 19200 within if
.. .. ..
else
true abort" Invalid baudrate"
then
..
..
..
;
is that it could attract c-programmers. If Forth was as common as c I'm sure that Forth would develop to be much faster than any meddlesome compiler type of language.
I guess that FIG always will have somewhat other interests than industry and it's standards, including Forth Inc and the gap don't have to be destructive - it could also be a challenge and driving force for development.
[toc] | [prev] | [next] | [standalone]
| From | Raimond Dragomir <raimond.dragomir@gmail.com> |
|---|---|
| Date | 2015-04-17 02:37 -0700 |
| Message-ID | <fe8641d5-67dd-4539-bb9f-7a9bc5f2bd0b@googlegroups.com> |
| In reply to | #38259 |
vineri, 17 aprilie 2015, 11:45:56 UTC+3, lehs a scris:
> Den fredag 17 april 2015 kl. 05:42:57 UTC+2 skrev hughag...@gmail.com:
> > On Thursday, April 16, 2015 at 8:32:43 AM UTC-7, lehs wrote:
> > > Den torsdag 16 april 2015 kl. 15:40:37 UTC+2 skrev Anton Ertl:
> > > > While not every system supports the Forth-2012 locals syntax {: ... :}
> > > > out of the box yet, you can add this syntax yourself easily by
> > > > downloading and unzipping
> > > >
> > > > http://www.forth200x.org/forth200x-code.zip
> >
> > > Thanks for the zip file! I might use this locals as a standard extension for programs intended to be portable.
> >
> > Anton's implementation has a bug in it. It initializes the locals right of | to whatever garbage value was in memory previously. If the user forgets to explicitly initialize these locals, his program will behave differently every time that it is run --- this lack of deterministic behavior will make the bug difficult to find.
> >
> > By comparison, my implementation in the novice package (http://www.forth.org/novice.html) initializes the local right of | to zero. If the programmer forgets to explicitly initialize them, he will discover his bug much more easily.
> >
> > Another problem with Anton Ertl's implementation is that he uses {: as the word that begins defining the locals. For over 20 years, since prior to ANS-Forth, everybody in the Forth community has used { for this (this is called the John Hopkins Format because that is where it originated about a quarter of a century ago). Anton pulled the rug out from under a huge amount of legacy code with his name change. The reason why he did this, is because SwiftForth uses { for multi-line comments, and he can't contradict Forth Inc. or they will remove him from the Forth-200x committee --- so he betrays the entire Forth community instead.
>
> It's old Fortran style not to initialize. I agree that initializing is better but I'm glad that ALLOCATE doesn't.
>
> I will look at your implementation too. Any fast code could be used if included, but then it seems to be an advantage with "odd" names to avoid redefining words in the actual system.
>
> For my own purposes, my own idea with a number of extra stacks like
>
> 07FF ALLOCATE THROW CONSTANT xst
> : >x ( x -- ) CELL xst +! xst @ ! ;
> : x> ( -- x ) xst @ @ -CELL xst +! ;
> : x@ ( -- x ) xst @ @ ;
> : x! ( n -- ) xst @ ! ;
> : x+! ( n -- ) xst @ +! ;
>
> works alright, to keep the parameters in track. While allocating 0 >x, x@ x! x+! could be used as locals. And sometimes an extra stack is handy as such.
>
> But what I like with Mark Wills idea
>
> : OpenSerialPort ( structaddr -- flag )
> locals{ struct baudRate parity startBit stopBit }
> set struct \ structaddr to struct (address of struct)
> struct @ set baudRate
> struct 1 cells + @ set parity
> struct 2 cells + @ set startBit
> struct 3 cells + @ set stopBit
> baudRate 1200 19200 within if
> .. .. ..
> else
> true abort" Invalid baudrate"
> then
> ..
> ..
> ..
> ;
>
> is that it could attract c-programmers. If Forth was as common as c I'm sure that Forth would develop to be much faster than any meddlesome compiler type of language.
>
> I guess that FIG always will have somewhat other interests than industry and it's standards, including Forth Inc and the gap don't have to be destructive - it could also be a challenge and driving force for development.
Maybe:
4 constant w
0 w field .baudrate
w field .parity
w field .startbit
w field .stop bit
drop
: OpenSerialPort ( structaddr -- flag )
locals{ struct baudRate parity startBit stopBit }
set struct \ structaddr to struct (address of struct)
struct .baudrate @ set baudRate
struct .parity @ set parity
struct .startbit @ set startBit
struct .stopbit @ set stopBit
...
etc.
will attract them more ... :)
[toc] | [prev] | [next] | [standalone]
| From | albert@spenarnc.xs4all.nl (Albert van der Horst) |
|---|---|
| Date | 2015-04-17 10:14 +0000 |
| Message-ID | <5530dd07$0$21217$e4fe514c@dreader37.news.xs4all.nl> |
| In reply to | #38252 |
In article <14f9c9aa-d31c-4dd0-b546-cc88a872e588@googlegroups.com>,
<hughaguilar96@gmail.com> wrote:
>On Thursday, April 16, 2015 at 8:32:43 AM UTC-7, lehs wrote:
>> Den torsdag 16 april 2015 kl. 15:40:37 UTC+2 skrev Anton Ertl:
>> > While not every system supports the Forth-2012 locals syntax {: ... :}
>> > out of the box yet, you can add this syntax yourself easily by
>> > downloading and unzipping
>> >
>> > http://www.forth200x.org/forth200x-code.zip
>
>> Thanks for the zip file! I might use this locals as a standard
>extension for programs intended to be portable.
>
>Anton's implementation has a bug in it. It initializes the locals right
>of | to whatever garbage value was in memory previously. If the user
>forgets to explicitly initialize these locals, his program will behave
>differently every time that it is run --- this lack of deterministic
>behavior will make the bug difficult to find.
Not a bug, a decision which you consider a design defect.
let's call the man and the horse by their names.
Groetjes Albert
--
Albert van der Horst, UTRECHT,THE NETHERLANDS
Economic growth -- being exponential -- ultimately falters.
albert@spe&ar&c.xs4all.nl &=n http://home.hccnet.nl/a.w.m.van.der.horst
[toc] | [prev] | [next] | [standalone]
| From | anton@mips.complang.tuwien.ac.at (Anton Ertl) |
|---|---|
| Date | 2015-04-17 10:18 +0000 |
| Message-ID | <2015Apr17.121844@mips.complang.tuwien.ac.at> |
| In reply to | #38252 |
hughaguilar96@gmail.com writes:
>On Thursday, April 16, 2015 at 8:32:43 AM UTC-7, lehs wrote:
>> Den torsdag 16 april 2015 kl. 15:40:37 UTC+2 skrev Anton Ertl:
>> > While not every system supports the Forth-2012 locals syntax {: ... :}
>> > out of the box yet, you can add this syntax yourself easily by
>> > downloading and unzipping
>> >=20
>> > http://www.forth200x.org/forth200x-code.zip
>
>> Thanks for the zip file! I might use this locals as a standard extension =
>for programs intended to be portable.
>
>Anton's implementation has a bug in it. It initializes the locals right of =
>| to whatever garbage value was in memory previously.
If this implementation did that, that would be according to the
specification, so it would not be a bug in the implementation. We
discussed this issue in the meetings, and the undefined initial value
was explicitly desired for performance reasons. So it's not a bug in
the specification as in "contradicts the requirements", either.
If you, like me, prefer not to have any uninitialized locals, just
don't use the "|" part of the new syntax. Define the locals where the
initial values becomes available, and if the system you use does not
support multiple locals definitions, complain to the system
implementor about it. This way they cannot say that there is "no
customer demand".
Back to this implementation: it actually initializes these locals to
0. Initializing them to $deadbeef or somesuch would be better for
finding missing initializations, though, and just as deterministic.
>Another problem with Anton Ertl's implementation is that he uses {: as the =
>word that begins defining the locals. For over 20 years, since prior to ANS=
>-Forth, everybody in the Forth community has used { for this (this is calle=
>d the John Hopkins Format because that is where it originated about a quart=
>er of a century ago).
The "{" syntax was already used before John Hayes from Johns Hopkins
published an implementation of that syntax in the SigForth Newsletter
in 1992. Unfortunatele, not everybody in the Forth community used it.
In particular, Forth, Inc. and their customers used "{" for comments.
As in earlier cases of conflicting uses of a name (e.g., NOT, OPEN,
and PARSE-WORD), we settled for using a different name rather than
breaking the system-specific code. If your system supports "{" for
locals, you can still use it, just as before.
- 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 2014: http://www.euroforth.org/ef14/
[toc] | [prev] | [next] | [standalone]
| From | hughaguilar96@gmail.com |
|---|---|
| Date | 2015-04-17 09:38 -0700 |
| Message-ID | <7b7484ff-61e1-48c5-9232-ac9aa581a81d@googlegroups.com> |
| In reply to | #38266 |
On Friday, April 17, 2015 at 3:37:52 AM UTC-7, Anton Ertl wrote:
> hughaguilar96@gmail.com writes:
> >Anton's implementation has a bug in it. It initializes the locals right of =
> >| to whatever garbage value was in memory previously.
>
> If this implementation did that, that would be according to the
> specification, so it would not be a bug in the implementation. We
> discussed this issue in the meetings, and the undefined initial value
> was explicitly desired for performance reasons. So it's not a bug in
> the specification as in "contradicts the requirements", either.
I don't make any distinction between design and implementation. To me, these words are synonymous.
My experience as a professional Forth programmer was at Testra writing MFX. The code that MFX generated had to run on the MiniForth processor, so that was the specification --- but what the MFX language behavior and implementation were up to me.
Have you ever been a professional Forth programmer? Or have you always been a school teacher?
Your {: has a bug in the design because it contradicts the requirements --- anybody with any sense knows that deterministic behavior is always a good thing --- that was the requirement: to make sense.
> If you, like me, prefer not to have any uninitialized locals, just
> don't use the "|" part of the new syntax.
This good idea can be extrapolated to: "just don't use the new Forth-200x standard."
This reminds me of a story about when a scientist was asked to explain entropy. He said: "If you have a barrel of wine and you pour a cup of sewage into it, then it becomes a barrel of sewage. OTOH, if you have a barrel of sewage and you pour a cup of wine into it, then it is still a barrel of sewage. That is entropy!"
> Back to this implementation: it actually initializes these locals to
> 0. Initializing them to $deadbeef or somesuch would be better for
> finding missing initializations, though, and just as deterministic.
>
> >Another problem with Anton Ertl's implementation is that he uses {: as the =
> >word that begins defining the locals. For over 20 years, since prior to ANS=
> >-Forth, everybody in the Forth community has used { for this (this is calle=
> >d the John Hopkins Format because that is where it originated about a quart=
> >er of a century ago).
>
> The "{" syntax was already used before John Hayes from Johns Hopkins
> published an implementation of that syntax in the SigForth Newsletter
> in 1992. Unfortunatele, not everybody in the Forth community used it.
> In particular, Forth, Inc. and their customers used "{" for comments.
> As in earlier cases of conflicting uses of a name (e.g., NOT, OPEN,
> and PARSE-WORD), we settled for using a different name rather than
> breaking the system-specific code. If your system supports "{" for
> locals, you can still use it, just as before.
Tell Forth Inc. and their customers to go fuck themselves!. Leon Wagner will kick you out of the Forth-200x committee and replace you with a more obedient "leader" (most likely Alex McDonald) --- but you will get to call yourself a leader without being laughed at, possibly for the first time in your life --- I will stand up and salute you, and I will take a selfie while doing this and email it to you. :-)
Believe me: nobody in the real world will take the ANS-Forth or Forth-200x standards seriously when they are owned by a corporation (for example: nobody takes C# seriously). People can just program in C instead of Forth --- the C language standard is not owned by any particular compiler vendor.
[toc] | [prev] | [next] | [standalone]
| From | "Alex McDonald" <blog@rivadpm.com> |
|---|---|
| Date | 2015-04-17 21:25 +0100 |
| Message-ID | <mgrq6j$nl1$1@dont-email.me> |
| In reply to | #38282 |
on 17/04/2015 17:38:24, hargh wrote: > Tell Forth Inc. and their customers to go fuck themselves!. Leon > Wagner wil l kick you out of the Forth-200x committee and replace you > with a more obed ient "leader" (most likely Alex McDonald) Hugh, eff off yourself. I've worked hard for this, and I won't have a jumped up twat like you spoil my promotion.
[toc] | [prev] | [next] | [standalone]
| From | "WJ" <w_a_x_man@yahoo.com> |
|---|---|
| Date | 2015-04-18 07:51 +0000 |
| Message-ID | <mgt2ee$5fr$1@dont-email.me> |
| In reply to | #38252 |
hughaguilar96@gmail.com wrote:
> Another problem with Anton Ertl's implementation is
> that he uses {: as the word that begins defining the
> locals. For over 20 years, since prior to ANS-Forth,
> everybody in the Forth community has used { for this
> (this is called the John Hopkins Format because that is
> where it originated about a quarter of a century ago).
> Anton pulled the rug out from under a huge amount of
> legacy code with his name change. The reason why he did
> this, is because SwiftForth uses { for multi-line
> comments, and he can't contradict Forth Inc. or they
> will remove him from the Forth-200x committee --- so he
> betrays the entire Forth community instead.
Why should the Forth community conform to what the inhuman
corporation wants?
Why doesn't the inhuman corporation serve the humans?
Why are so many humans willing and obedient slaves of their
inhuman masters?
[toc] | [prev] | [next] | [standalone]
| From | hughaguilar96@gmail.com |
|---|---|
| Date | 2015-04-19 08:45 -0700 |
| Message-ID | <f89ae8a4-62c3-4cc4-8f02-da141860ee47@googlegroups.com> |
| In reply to | #38325 |
On Saturday, April 18, 2015 at 12:52:43 AM UTC-7, WJ wrote:
> hughaguilar96@gmail.com wrote:
>
> > Another problem with Anton Ertl's implementation is
> > that he uses {: as the word that begins defining the
> > locals. For over 20 years, since prior to ANS-Forth,
> > everybody in the Forth community has used { for this
> > (this is called the John Hopkins Format because that is
> > where it originated about a quarter of a century ago).
> > Anton pulled the rug out from under a huge amount of
> > legacy code with his name change. The reason why he did
> > this, is because SwiftForth uses { for multi-line
> > comments, and he can't contradict Forth Inc. or they
> > will remove him from the Forth-200x committee --- so he
> > betrays the entire Forth community instead.
>
> Why should the Forth community conform to what the inhuman
> corporation wants?
Normally, people do what the corporation tells them to do because they get a paycheck from the corporation.
Stephen Pelc, for example, gets a paycheck from Forth Inc. --- this is why, as a member of the Forth-200x committee, he always agrees with Leon Wagner and does what Leon Wagner tells him to do.
As for Anton Ertl, I am not aware of him getting a paycheck from Forth Inc., yet he always agrees with Leon Wagner and does what Leon Wagner tells him to do. Most likely he just enjoys the prestige of being the chairperson of the committee --- he is willing to be totally obedient in exchange for the appearance of being a leader.
[toc] | [prev] | [next] | [standalone]
| From | stephen@mpeforth.com (Stephen Pelc) |
|---|---|
| Date | 2015-04-19 16:24 +0000 |
| Message-ID | <5533d6a5.189894182@news.eternal-september.org> |
| In reply to | #38374 |
On Sun, 19 Apr 2015 08:45:38 -0700 (PDT), hughaguilar96@gmail.com wrote: >Stephen Pelc, for example, gets a paycheck from Forth Inc. --- this is why,= > as a member of the Forth-200x committee, he always agrees with Leon Wagner= > and does what Leon Wagner tells him to do. Calumny and lies. Grow up, Hugh. Stephen -- Stephen Pelc, stephenXXX@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
[toc] | [prev] | [next] | [standalone]
| From | hughaguilar96@gmail.com |
|---|---|
| Date | 2015-04-19 09:58 -0700 |
| Message-ID | <135cafe1-7dfa-4b3c-8d44-e27d03bb4da0@googlegroups.com> |
| In reply to | #38375 |
On Sunday, April 19, 2015 at 9:24:53 AM UTC-7, Stephen Pelc wrote: > On Sun, 19 Apr 2015 08:45:38 -0700 (PDT), hughaguilar96@gmail.com > wrote: > > >Stephen Pelc, for example, gets a paycheck from Forth Inc. --- this is why,= > > as a member of the Forth-200x committee, he always agrees with Leon Wagner= > > and does what Leon Wagner tells him to do. > > Calumny and lies. Grow up, Hugh. > > Stephen Elizabeth Rather has stated on comp.lang.forth that Forth Inc. and MPE have done "joint projects" together --- I assume that you were paid for your programming work --- or are you a hobbyist programmer now?
[toc] | [prev] | [next] | [standalone]
| From | "Alex McDonald" <blog@rivadpm.com> |
|---|---|
| Date | 2015-04-19 19:00 +0100 |
| Message-ID | <mh0qdu$jgr$1@dont-email.me> |
| In reply to | #38376 |
on 19/04/2015 17:58:33, wrote: > On Sunday, April 19, 2015 at 9:24:53 AM UTC-7, Stephen Pelc wrote: >> On Sun, 19 Apr 2015 08:45:38 -0700 (PDT), hughaguilar96@gmail.com >> wrote: >> >> >Stephen Pelc, for example, gets a paycheck from Forth Inc. --- this is why,> > as a member of the Forth-200x committee, he always agrees with Leon Wagner> > and does what Leon Wagner tells him to do. >> >> Calumny and lies. Grow up, Hugh. >> >> Stephen > > Elizabeth Rather has stated on comp.lang.forth that Forth Inc. and MPE > have done "joint projects" together --- I assume that you were paid > for your programming work --- or are you a hobbyist programmer now? > Let's rejoice in the fact that Hugh hasn't been paid by anyone for anything to do with Forth since he got fired from Testra in the mid 1990s. The future is equally promising.
[toc] | [prev] | [next] | [standalone]
| From | hughaguilar96@gmail.com |
|---|---|
| Date | 2015-04-19 12:27 -0700 |
| Message-ID | <554e57af-8c94-4544-ac36-87b03ccfe15f@googlegroups.com> |
| In reply to | #38376 |
On Sunday, April 19, 2015 at 9:58:33 AM UTC-7, hughag...@gmail.com wrote: > On Sunday, April 19, 2015 at 9:24:53 AM UTC-7, Stephen Pelc wrote: > > On Sun, 19 Apr 2015 08:45:38 -0700 (PDT), hughaguilar96@gmail.com > > wrote: > > > > >Stephen Pelc, for example, gets a paycheck from Forth Inc. --- this is why,= > > > as a member of the Forth-200x committee, he always agrees with Leon Wagner= > > > and does what Leon Wagner tells him to do. > > > > Calumny and lies. Grow up, Hugh. > > > > Stephen > > Elizabeth Rather has stated on comp.lang.forth that Forth Inc. and MPE have done "joint projects" together --- I assume that you were paid for your programming work --- or are you a hobbyist programmer now? For the record, here is the thread: https://groups.google.com/forum/#!searchin/comp.lang.forth/elizabeth$20joint%7Csort:date/comp.lang.forth/nDj10O-g8A0/XWBsKkGcA44J On Saturday, April 19, 2014 at 1:24:01 AM UTC-7, Elizabeth D. Rather wrote: > On 4/18/14 9:08 PM, Rod Pemberton wrote: > > On Fri, 18 Apr 2014 09:46:48 -0400, <cslarsen@gmail.com> wrote: > > > >> I was hoping I could get some recommendations on a Forth system that I > >> can embed in C. > >> > >> What I'm currently looking for is > >> > >> - Able to produce Forth bytecode that can be transmitted over the > >> network and executed there > > > > I'm not sure of any that can produce bytecode ... That would dramatically > > limit the number of definable Forth words or dictionary size, although > > Forths which use bytecode probably do exist. > > LOL, there have been bytecode Forths ever since the first MacForth (by > Don Colburn) in 1984. MPE and FORTH, Inc. have both done extensive work > with bytecode Forths, including a major joint project in the 90's. > > The standard approach, used by many languages, is to code the most > common 127 functions in one-byte codes, and use the high bit to signal > that there is a 2nd byte representing more functions. It's not terribly > hard to implement such a system with very respectable performance. > > Cheers, > Elizabeth Notice, btw, that she doesn't know how a byte-code interpreter works. The reason why the number of byte-codes is sometimes limited to 127 is that the byte-code is an index into an array of pointers (a jump-table) and the pointers are 2 bytes. This was true on the 65c02 that only allows 8-bit indexes. On a processor with 16-bit indexes, the byte-code would be shifted left by one bit to make a 9-bit index into a 256-cell jump-table. There is no reason to use one bit in the byte-code to indicate that there is a second byte-code --- you just have one of the entries in the jump-table execute code pull a second byte-code and uses it as an index to a second jump-table for your secondary functions (these are slightly slower to get to than the primary functions). Considering that Elizabeth Rather doesn't know how a byte-code interpreter works, it seems unlikely that any of the programming was done at Forth Inc.. Most likely, Forth Inc. (Elizabeth Rather herself) did the selling, and then Forth Inc. out-sourced the actual work to MPE because they didn't have any programmers on staff who were capable of writing original software (all of Forth Inc.'s programmers just maintain decades-old software written by Charles Moore). This is done in the plumbing business sometimes. There are plumbers who are good at selling. This mostly involves doing "free inspections" that involve walking around the customer's house telling the customer that various valves need to be replaced lest that they break and the house floods. These guys can usually replace the valves under the sink, as this only requires hand tools (this mostly works with elderly customers who can't crawl under a sink and do the job themselves). If the super-salesman succeeds in selling a big job however, he isn't capable of doing it himself, so he turns the job over to a real plumber --- but he demands a "referral fee" from the plumber (sometimes as much as 20%). This was the OTA project: On Sunday, May 25, 2014 at 7:54:33 PM UTC-7, Elizabeth D. Rather wrote: > On 5/25/14 12:31 PM, VisualForth.com wrote: > > On Friday, April 18, 2014 9:46:48 AM UTC-4, csla...@gmail.com wrote: > >> > >> What I'm currently looking for is > >> - Able to produce Forth bytecode that can be transmitted over the network and executed there > >> - Able to embed as an execution engine in C or C++ > >> - Able to have Forth words call C functions (no need for a full-blown FFI, if I can modify the source and translate the call to C, that'd be fine) > >> - Preferrably have a small memory footprint > >> ... > >> What I'd really like to avoid is rolling my own Forth. I've done that before, but right now I need something that is robust. > > > > Google for "Open Terminal Architecture" (OTA)and you will find it. > > A Byte-Code Forth which is a Byte-Code C at the same time. > > Developed by our famous Forth factories. > > > > It is robust, it is ISO/IEC 20060, and you find the specifications at Amazon. > > There it says: > > "The overall architecture of the Open Terminal Architecture is described in Appendix F, "System Architecture," and is based on a Virtual Machine (VM) that can be programmed using high-level languages such as Forth or C" > > > > "This International Standard describes a set of functions to be implemented in terminals in terms of instructions for a Virtual Machine. With these functions the application programmer is able to generate application software that is compact, portable and certifiable ..." > > Distributed through American National Standards Institute (ANSI) (August 23, 2007 > > > > And there is more than a specification! > > > > OTA exists and has been field tested successfully. > > > >> - It must be open source > > I don't know about this. Ask Elizabeth. > > I am sure the time has come to make it open source. > > Whew, a lot of issues. To begin with, OTA is an application-oriented > language for programming smart-card terminals, not a general-purpose > system. The user-level commands include a lot of Forth, but mostly deal > with smart-card issues. > > Second, the smart-card industry is understandably incredibly security > conscious. They will not encourage random engineers to start developing > their own smart-card terminals! > > Third, although the documentation has been published, I am pretty sure > the code has not. Although it built on underlying technology from MPE > and FORTH, Inc., it was developed under contract and neither of us > "owns" it or has the ability to control its release status. > > And that's only a start. But, by all means, read the document. It will > give you a lot of hints for your own work. > > Cheers, > Elizabeth
[toc] | [prev] | [next] | [standalone]
| From | stephen@mpeforth.com (Stephen Pelc) |
|---|---|
| Date | 2015-04-19 19:42 +0000 |
| Message-ID | <55340478.201624849@news.eternal-september.org> |
| In reply to | #38376 |
On Sun, 19 Apr 2015 09:58:31 -0700 (PDT), hughaguilar96@gmail.com wrote: >On Sunday, April 19, 2015 at 9:24:53 AM UTC-7, Stephen Pelc wrote: >> On Sun, 19 Apr 2015 08:45:38 -0700 (PDT), hughaguilar96@gmail.com >> wrote: >> >> >Stephen Pelc, for example, gets a paycheck from Forth Inc. --- this is why,= >> > as a member of the Forth-200x committee, he always agrees with Leon Wagner= >> > and does what Leon Wagner tells him to do. >> >> Calumny and lies. Grow up, Hugh. >> >> Stephen > >Elizabeth Rather has stated on comp.lang.forth that Forth Inc. and MPE have >done "joint projects" together --- I assume that you were paid for your >programming work --- or are you a hobbyist programmer now? We were both paid by the same client. Please think before posting. Stephen -- Stephen Pelc, stephenXXX@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
[toc] | [prev] | [next] | [standalone]
| From | hughaguilar96@gmail.com |
|---|---|
| Date | 2015-04-19 13:49 -0700 |
| Message-ID | <7aaf206f-8019-4623-a421-8db120a53b27@googlegroups.com> |
| In reply to | #38383 |
On Sunday, April 19, 2015 at 12:42:12 PM UTC-7, Stephen Pelc wrote:
> On Sun, 19 Apr 2015 09:58:31 -0700 (PDT), hughaguilar96@gmail.com
> wrote:
>
> >On Sunday, April 19, 2015 at 9:24:53 AM UTC-7, Stephen Pelc wrote:
> >> On Sun, 19 Apr 2015 08:45:38 -0700 (PDT), hughaguilar96@gmail.com
> >> wrote:
> >>
> >> >Stephen Pelc, for example, gets a paycheck from Forth Inc. --- this is why,=
> >> > as a member of the Forth-200x committee, he always agrees with Leon Wagner=
> >> > and does what Leon Wagner tells him to do.
> >>
> >> Calumny and lies. Grow up, Hugh.
> >>
> >> Stephen
> >
> >Elizabeth Rather has stated on comp.lang.forth that Forth Inc. and MPE have
> >done "joint projects" together --- I assume that you were paid for your
> >programming work --- or are you a hobbyist programmer now?
>
> We were both paid by the same client. Please think before posting.
>
> Stephen
I think that Leon Wagner owns your vote on the Forth-200x committee --- you are not going to bite the hand that feeds you --- Forth Inc. is selling jobs that they aren't capable of doing, then out-sourcing the work to MPE.
Changing the name of { to {: only benefits Forth Inc., because they use { for multi-line comments --- everybody else in the Forth community, including MPE, has been using { for 20+ years. You must have had a good reason ($$$) to agree to a change that only benefits Forth Inc. but results in a big hassle for everybody else including MPE (all of the legacy code using { for locals has to be manually rewritten to use {: now).
On a related note: why did FIELD get changed to FIELD: in Forth-200x? FIELD is another word that has been in use for 20+ years. Was Forth Inc. using the name FIELD for something other than stuct fields? None of the books from Forth Inc. describe how to implement FIELD --- afaik, nobody at Forth Inc. knows what a struct is --- so it wouldn't surprise me if SwiftForth uses the word FIELD for some unrelated purpose.
[toc] | [prev] | [next] | [standalone]
| From | anton@mips.complang.tuwien.ac.at (Anton Ertl) |
|---|---|
| Date | 2015-04-20 09:39 +0000 |
| Message-ID | <2015Apr20.113948@mips.complang.tuwien.ac.at> |
| In reply to | #38389 |
hughaguilar96@gmail.com writes:
>On a related note: why did FIELD get changed to FIELD: in Forth-200x?
Different behaviour for FIELD in different systems. E.g., Gforth has
FIELD ( align1 offset1 align size "name" - align2 offset2 )
while other Forth systems may have FIELD with other behaviour
(interestingly, the versions of VFX, SwiftForth, and iForth-2.1 i just
checked don't have FIELD); in any case, an early version of the
proposal proposed FIELD with a behaviour that's incompatible with
Gforth's FIELD, so the name of the proposed word was changed to avoid
conflicting definitions.
- 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 2014: http://www.euroforth.org/ef14/
[toc] | [prev] | [next] | [standalone]
Page 6 of 9 — ← Prev page 1 2 3 4 5 [6] 7 8 9 Next page →
Back to top | Article view | comp.lang.forth
csiph-web