info
Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss
Perter Knaggs makes a fool of himself in public
801 views
Skip to first unread message
hughag...@gmail.com
Apr 9, 2019, 2:26:32 AM4/9/19
to
I read through Peter Knaggs paper on lists:
http://www.complang.tuwien.ac.at/anton/euroforth/ef18/papers/knaggs.pdf
His FOREACH I NEXT fail badly because they don't allow the
item to be removed from the list during the traversal, such
as by inserting it into a different list.
Doing this would cause NEXT to return a corrupted value
(in a linked list, because the link has been changed).
The FOREACH traversal would go haywire! As they say at MPE: "Oops!"
Does he not know that the word I is already used in DO loops???
His word set is too big. I have LINK and DELINK , whereas he has:
LIST+ LIST- +LIST -LIST CONCAT >LIST LIST>
All of this is trivially done with LINK and DELINK in my LIST.4TH.
He seems proud of his LIST@ and LIST! accepting a negative index.
This is trivial to do with my NTH and LENGTH though.
The negative indexes aren't common enough to complicate NTH
by making it check for a negative index every time it is executed.
He doesn't have anything like my FIND-NODE or FIND-PRIOR .
He does have ?LIST but he is only matching a one-cell item exactly.
If this one-cell item is a pointer to a struct (typical),
then he doesn't provide a way to do anything except match this pointer.
My FIND-NODE and FIND-PRIOR allow the user to pass in the xt
of a comparer function that returns a flag if the item matches or not.
His #LIST has the same weird limitation as ?LIST in that it only
matches a one-cell item exactly, not using a comparer function.
His list is of one-cell items. These can be pointers to structs.
He doesn't have this integrated with an OOP system like I do, though.
He doesn't have anything like my CLONE-NODE and CLONE-LIST
that depend upon having ALLOCATION available.
He doesn't have anything like my SORT-LIST that sorts a list
given the xt of a comparer function.
All in all, I think that Peter Knaggs made a fool of himself
publicly by writing this EuroForth paper.
He is pretending to be an expert on a subject that he knows nothing
about. He also has refused to provide source-code ---
most likely, because all he has produced so far is a bug-ridden mess.
What exactly is Peter Knaggs qualification to be on the Forth-200x committee?
He is an employee of MPE --- this implies that his only qualification
is loyalty to Stephen Pelc --- he just gives Stephen Pelc a second vote.
His EuroForth paper on lists indicates incompetence as a Forth programmer.
He has no qualification to be a leader in the Forth community.
http://www.complang.tuwien.ac.at/anton/euroforth/ef18/papers/knaggs.pdf
His FOREACH I NEXT fail badly because they don't allow the
item to be removed from the list during the traversal, such
as by inserting it into a different list.
Doing this would cause NEXT to return a corrupted value
(in a linked list, because the link has been changed).
The FOREACH traversal would go haywire! As they say at MPE: "Oops!"
Does he not know that the word I is already used in DO loops???
His word set is too big. I have LINK and DELINK , whereas he has:
LIST+ LIST- +LIST -LIST CONCAT >LIST LIST>
All of this is trivially done with LINK and DELINK in my LIST.4TH.
He seems proud of his LIST@ and LIST! accepting a negative index.
This is trivial to do with my NTH and LENGTH though.
The negative indexes aren't common enough to complicate NTH
by making it check for a negative index every time it is executed.
He doesn't have anything like my FIND-NODE or FIND-PRIOR .
He does have ?LIST but he is only matching a one-cell item exactly.
If this one-cell item is a pointer to a struct (typical),
then he doesn't provide a way to do anything except match this pointer.
My FIND-NODE and FIND-PRIOR allow the user to pass in the xt
of a comparer function that returns a flag if the item matches or not.
His #LIST has the same weird limitation as ?LIST in that it only
matches a one-cell item exactly, not using a comparer function.
His list is of one-cell items. These can be pointers to structs.
He doesn't have this integrated with an OOP system like I do, though.
He doesn't have anything like my CLONE-NODE and CLONE-LIST
that depend upon having ALLOCATION available.
He doesn't have anything like my SORT-LIST that sorts a list
given the xt of a comparer function.
All in all, I think that Peter Knaggs made a fool of himself
publicly by writing this EuroForth paper.
He is pretending to be an expert on a subject that he knows nothing
about. He also has refused to provide source-code ---
most likely, because all he has produced so far is a bug-ridden mess.
What exactly is Peter Knaggs qualification to be on the Forth-200x committee?
He is an employee of MPE --- this implies that his only qualification
is loyalty to Stephen Pelc --- he just gives Stephen Pelc a second vote.
His EuroForth paper on lists indicates incompetence as a Forth programmer.
He has no qualification to be a leader in the Forth community.
hughag...@gmail.com
Apr 9, 2019, 11:31:04 PM4/9/19
to
And here is a message from the Forth-200x chair-person:
On Saturday, November 17, 2018 at 9:54:54 PM UTC-7, ste...@mpeforth.com wrote:
> My name is Stephen Pelc.
> ...
> If you can't stomach the word MASTURBATE you cannot be able
> to raise children from puberty into adulthood.
The Forth-200x committee is basically a circle-jerk.
We have Peter Knaggs who goes to EuroForth-2018 and claims to be
the world's expert on linked lists in Forth,
but he doesn't have any working code.
We have Andrew Haley who goes to EuroForth-2018 and claims to be
the world's expert on a <SWITCH with constant time in Forth,
but he doesn't have any working code.
We have Anton Ertl and Bernd Paysan who go to EuroForth-2018 and
claim to be the world's experts on quotations, but their paper
seems to have no point except to attack the rquotations, claiming
that rquotations fail to access the parent function's local
variables despite the HOF having local variables of its own.
They are lying, of course.
I provided this feature a few days after HumptyDumpty posted his
prototype rquotations that lacked this feature. This was in mid-2016.
These are all Forth-200x committee members jerking each other off.
They are just fantasizing about being the world's experts on
Forth programming. They imagine lowly Forth programmers such as
myself being totally dependent upon their great wisdom.
They can't actually write working Forth code though!
The Forth-200x committee members are the enemies of Forth.
People in the real world (C programmers, etc.) see their incompetence
and gleefully declare that this implies that all Forthers are incompetent.
It is always worthwhile to shine a spotlight on the incompetence
of the Forth-200x committee members --- hopefully shame them into giving up.
Peter Knaggs is not only failing to implement a linked list,
but his design is just a jumble of nonsense and vague dreams.
This is not a design developed by a programmer!
Even if he got is design to work, it would still be worthless.
When (if) our big-time Forth-200x committee member
(Stephen Pelc's pocket-boy) gets his linked-list implemented,
I challenge him to write some simple functions.
1.) Define a list with elements containing a single float.
2.) For testing purposes, generate a list containing
30 random floats in the range [0,1).
3.) For the test list, filter out all of the nodes
with a value < 0.5 and put them in a different list.
4.) Sort the test list ascending, then split it into
two lists of nodes < 0.5 and above.
5.) Clone the test list.
Now, define a child class that has two floats
(the first one is real, the second imaginary).
All of the test functions written above
(#3,#4,#5) should work on lists of the child
type without modification or recompilation.
For me, being a Forth programmer is all about Forth programming.
I enjoy writing Forth code that works. I don't skip this step.
So, here is how I would do the above challenge:
1.) This code defines a class called REAL and provides
KILL-REAL and SHOW-REAL that are typical for classes.
-------------------------------------------------------------------
list
f field .real
constant real
: init-real ( node -- node ) \ float: real --
init-list >r
r@ .real f!
r> ;
: new-real ( -- node ) \ float: real --
real alloc
init-real ;
: kill-real ( head -- )
each[ dealloc ]each ;
: show-real ( head -- )
each[ cr .real f@ f. ]each ;
-------------------------------------------------------------------
Peter Knaggs will fail on writing KILL-REAL because deallocating
a node will corrupt its link field so NEXT won't work.
2.) This code generates a list containing 30 random floats in the range [0,1).
-------------------------------------------------------------------
: test2 ( -- head ) \ generate a test list
nil
30 0 do frnd new-real link loop ;
-------------------------------------------------------------------
3.) This code filters out all of the nodes
with a value < 0.5 and put them in a different list.
-------------------------------------------------------------------
: <test3> ( sml-head big-head node -- )
init-list \ the node is going to another list
dup .real f@ 0.5e f< if swap >r link r> \ link to SML-HEAD
else link then ; \ link to BIG-HEAD
: test3 ( head -- sml-head big-head ) \ filter small nodes (<0.5) into SML-HEAD
nil nil rot ['] <test3> each ;
-------------------------------------------------------------------
Peter Knaggs will fail on writing TEST3 because INIT-LIST changes
the link field of the node so NEXT won't work.
4.) This code sorts the list ascending, then splits it into
two lists of nodes < 0.5 and above.
-------------------------------------------------------------------
: <sort-real> ( new-node node -- new-node prior? )
over .real f@ .real f@ f< ;
: <test4> ( node -- flag )
.real f@ 0.5e f>= ;
: test4 ( head -- sml-head big-head )
['] <sort-real> sort-list
dup ['] <test4> find-node delink ;
-------------------------------------------------------------------
Peter Knaggs will fail on writing TEST4 because he doesn't have
DELINK that splits a list at an arbitrary node.
5.) This is code to clone a list of reals.
-------------------------------------------------------------------
get-current synonym test5 clone-list ( head -- clone )
-------------------------------------------------------------------
Peter Knaggs will fail on writing TEST5 because he doesn't have
ALLOCATION available.
Note that this is a simple example because there are no pointers in
the class. If there are pointers, they have to be cloned manually.
This is code to define a new COMPLEX class.
-------------------------------------------------------------------
real
f field .imaj
constant complex
: init-complex ( node -- node ) \ float: real imaj --
fswap \ float: imaj real --
init-real >r
r@ .imaj f!
r> ;
: new-complex ( -- node ) \ float: real imaj --
complex alloc
init-complex ;
: test2c ( -- head ) \ generate a test list
nil
30 0 do frnd frnd new-complex link loop ;
: show-complex ( head -- )
each[ cr dup .real f@ f. .imaj f@ f. ]each ;
-------------------------------------------------------------------
Peter Knaggs will fail at this because he doesn't know how OOP works.
Here we use TEST2C instead of TEST2 to generate the test list.
We use SHOW-COMPLEX instead of SHOW-REAL to view the list.
KILL-REAL works on COMPLEX lists.
TEST3 TEST4 TEST5 all work on COMPLEX lists without modification
or recompilation.
This seems like very novice-level programming to me.
That is why it is called a "novice-package" --- novices can easily
learn to write code like this --- Peter Knaggs, for example.
On Saturday, November 17, 2018 at 9:54:54 PM UTC-7, ste...@mpeforth.com wrote:
> My name is Stephen Pelc.
> ...
> If you can't stomach the word MASTURBATE you cannot be able
> to raise children from puberty into adulthood.
The Forth-200x committee is basically a circle-jerk.
We have Peter Knaggs who goes to EuroForth-2018 and claims to be
the world's expert on linked lists in Forth,
but he doesn't have any working code.
We have Andrew Haley who goes to EuroForth-2018 and claims to be
the world's expert on a <SWITCH with constant time in Forth,
but he doesn't have any working code.
We have Anton Ertl and Bernd Paysan who go to EuroForth-2018 and
claim to be the world's experts on quotations, but their paper
seems to have no point except to attack the rquotations, claiming
that rquotations fail to access the parent function's local
variables despite the HOF having local variables of its own.
They are lying, of course.
I provided this feature a few days after HumptyDumpty posted his
prototype rquotations that lacked this feature. This was in mid-2016.
These are all Forth-200x committee members jerking each other off.
They are just fantasizing about being the world's experts on
Forth programming. They imagine lowly Forth programmers such as
myself being totally dependent upon their great wisdom.
They can't actually write working Forth code though!
The Forth-200x committee members are the enemies of Forth.
People in the real world (C programmers, etc.) see their incompetence
and gleefully declare that this implies that all Forthers are incompetent.
It is always worthwhile to shine a spotlight on the incompetence
of the Forth-200x committee members --- hopefully shame them into giving up.
Peter Knaggs is not only failing to implement a linked list,
but his design is just a jumble of nonsense and vague dreams.
This is not a design developed by a programmer!
Even if he got is design to work, it would still be worthless.
When (if) our big-time Forth-200x committee member
(Stephen Pelc's pocket-boy) gets his linked-list implemented,
I challenge him to write some simple functions.
1.) Define a list with elements containing a single float.
2.) For testing purposes, generate a list containing
30 random floats in the range [0,1).
3.) For the test list, filter out all of the nodes
with a value < 0.5 and put them in a different list.
4.) Sort the test list ascending, then split it into
two lists of nodes < 0.5 and above.
5.) Clone the test list.
Now, define a child class that has two floats
(the first one is real, the second imaginary).
All of the test functions written above
(#3,#4,#5) should work on lists of the child
type without modification or recompilation.
For me, being a Forth programmer is all about Forth programming.
I enjoy writing Forth code that works. I don't skip this step.
So, here is how I would do the above challenge:
1.) This code defines a class called REAL and provides
KILL-REAL and SHOW-REAL that are typical for classes.
-------------------------------------------------------------------
list
f field .real
constant real
: init-real ( node -- node ) \ float: real --
init-list >r
r@ .real f!
r> ;
: new-real ( -- node ) \ float: real --
real alloc
init-real ;
: kill-real ( head -- )
each[ dealloc ]each ;
: show-real ( head -- )
each[ cr .real f@ f. ]each ;
-------------------------------------------------------------------
Peter Knaggs will fail on writing KILL-REAL because deallocating
a node will corrupt its link field so NEXT won't work.
2.) This code generates a list containing 30 random floats in the range [0,1).
-------------------------------------------------------------------
: test2 ( -- head ) \ generate a test list
nil
30 0 do frnd new-real link loop ;
-------------------------------------------------------------------
3.) This code filters out all of the nodes
with a value < 0.5 and put them in a different list.
-------------------------------------------------------------------
: <test3> ( sml-head big-head node -- )
init-list \ the node is going to another list
dup .real f@ 0.5e f< if swap >r link r> \ link to SML-HEAD
else link then ; \ link to BIG-HEAD
: test3 ( head -- sml-head big-head ) \ filter small nodes (<0.5) into SML-HEAD
nil nil rot ['] <test3> each ;
-------------------------------------------------------------------
Peter Knaggs will fail on writing TEST3 because INIT-LIST changes
the link field of the node so NEXT won't work.
4.) This code sorts the list ascending, then splits it into
two lists of nodes < 0.5 and above.
-------------------------------------------------------------------
: <sort-real> ( new-node node -- new-node prior? )
over .real f@ .real f@ f< ;
: <test4> ( node -- flag )
.real f@ 0.5e f>= ;
: test4 ( head -- sml-head big-head )
['] <sort-real> sort-list
dup ['] <test4> find-node delink ;
-------------------------------------------------------------------
Peter Knaggs will fail on writing TEST4 because he doesn't have
DELINK that splits a list at an arbitrary node.
5.) This is code to clone a list of reals.
-------------------------------------------------------------------
get-current synonym test5 clone-list ( head -- clone )
-------------------------------------------------------------------
Peter Knaggs will fail on writing TEST5 because he doesn't have
ALLOCATION available.
Note that this is a simple example because there are no pointers in
the class. If there are pointers, they have to be cloned manually.
This is code to define a new COMPLEX class.
-------------------------------------------------------------------
real
f field .imaj
constant complex
: init-complex ( node -- node ) \ float: real imaj --
fswap \ float: imaj real --
init-real >r
r@ .imaj f!
r> ;
: new-complex ( -- node ) \ float: real imaj --
complex alloc
init-complex ;
: test2c ( -- head ) \ generate a test list
nil
30 0 do frnd frnd new-complex link loop ;
: show-complex ( head -- )
each[ cr dup .real f@ f. .imaj f@ f. ]each ;
-------------------------------------------------------------------
Peter Knaggs will fail at this because he doesn't know how OOP works.
Here we use TEST2C instead of TEST2 to generate the test list.
We use SHOW-COMPLEX instead of SHOW-REAL to view the list.
KILL-REAL works on COMPLEX lists.
TEST3 TEST4 TEST5 all work on COMPLEX lists without modification
or recompilation.
This seems like very novice-level programming to me.
That is why it is called a "novice-package" --- novices can easily
learn to write code like this --- Peter Knaggs, for example.
hughag...@gmail.com
Apr 11, 2019, 11:23:58 PM4/11/19
to
On Monday, April 8, 2019 at 11:26:32 PM UTC-7, hughag...@gmail.com wrote:
> What exactly is Peter Knaggs qualification to be on the Forth-200x committee?
> He is an employee of MPE --- this implies that his only qualification
> is loyalty to Stephen Pelc --- he just gives Stephen Pelc a second vote.
> His EuroForth paper on lists indicates incompetence as a Forth programmer.
> He has no qualification to be a leader in the Forth community.
I assume that because Peter Knaggs is on Stephen Pelc's payroll,
> What exactly is Peter Knaggs qualification to be on the Forth-200x committee?
> He is an employee of MPE --- this implies that his only qualification
> is loyalty to Stephen Pelc --- he just gives Stephen Pelc a second vote.
> His EuroForth paper on lists indicates incompetence as a Forth programmer.
> He has no qualification to be a leader in the Forth community.
he votes on the Forth-200x committee exactly the way that
his boss votes. So, he presumably voted in favor of the fake quotations
(the fake quotations lack access to the parent function's locals,
whereas my rquotations access the parent function's locals despite
the HOF having locals of its own).
This is how my example would be done with rquotations:
--------------------------------------------------------------------
: rtest3 { head | sml big -- sml-head big-head } \ filter small nodes (<0.5) into SML-HEAD
head r[ \ node --
init-list \ the node is going to another list
dup .real f@ 0.5e f< if sml swap link to sml
else big swap link to big then
]r |each
sml big ;
: rtest4 { head | sml big -- sml-head big-head } \ sort and then filter small nodes (<0.5) into SML-HEAD
head ['] <sort-real> sort-list \ -- head
dup r[ .real f@ 0.5e f>= ]r |find-node delink ;
--------------------------------------------------------------------
RTEST3 is somewhat more readable with rquotations than TEST3 that is
using a pseudo-quotation. There is no need for a separate function
<TEST3> to act as the pseudo-quotation, but rather the rquotation
is in the middle of RTEST3 --- also, local variables SML and BIG
are used for small and big lists, rather than stack juggling.
Note that my { that defines locals using the John Hopkins notation
initializes the locals to the right of the | to zero
(in RTEST3 this initializes these to NIL pointers) --- failing to
initialize the locals to the right of the | to zero is another
gross mistake that the Forth-200x committee made.
RTEST4 still uses a pseudo-quotation <SORT-REAL> for SORT-LIST
because I don't have an rquotation version of SORT-LIST available.
RTEST4 does use an rquotation instead of the pseudo-quotation
<TEST4> which helps readability somewhat. The rquotation doesn't
access any local variables though, so the fake-quotations
could have been used in this case.
Anton Ertl and Bernd Paysan totally lied in their EuroForth-2018
paper: "Closures --- the Forth Way."
That said: "the higher-order word that calls the rquotation must not use locals"
They are liars! These are my higher-order functions (that have locals):
--------------------------------------------------------------------------
: |each ( i*x head rq -- j*x ) \ quotation: i*x node -- j*x
{ rq | next -- }
begin ?dup while \ -- node
dup .fore @ to next
rq rex
next repeat ;
: |find-node ( i*x head rq -- j*x node|false ) \ quotation: i*x node -- j*x flag
{ node rq | next -- node|false }
begin node while
node .fore @ to next
node rq rex if node exit then
next to node repeat
false ;
: |find-prior ( i*x head rq -- j*x -1|node|false ) \ quotation: i*x node -- j*x flag
-1 { node rq prior | next -- prior|false } \ prior is -1, meaning found node was the head
begin node while
node .fore @ to next
node rq rex if prior exit then
node to prior next to node repeat
false ;
--------------------------------------------------------------------------
The HOF almost always needs locals --- to hold the RQ, for one thing ---
also to improve readability if there is a lot of internal data.
Anton Ertl and Bernd Paysan used EuroForth as a platform for attacking
rquotations, blatantly lying by saying that rquotations don't work.
Their paper, "Closures --- the Forth Way," was in the refereed section.
Who exactly are these referees that allow blatant lying???
Do they have names?
The EuroForth website says:
"A special "Refereed Section" was introduced with the tenth conference
in order to make it more attractive to academic institutes."
How many academic institutes are going to tolerate liars???
jpit...@gmail.com
Apr 12, 2019, 9:53:56 AM4/12/19
to
This is the event,
where the book I prepared with Chuck's contents was handend over to him by Paul Bennett, as I could not be there myself - together with my A Start With Forth - and Stephen Pelc's book. - as you can see in the video.
Part of ther Forthn Bookshelf I generated over the last 6 years
https://www.amazon.co.uk/l/B00N8HVEZM?_encoding=UTF8&redirectedFromKindleDbs=true&rfkd=1&shoppingPortalEnabled=true
Not of interest for you really, as you know better anyway.
But it is fun to see which of these books amazon customers are interested in,
They are about 10% of the top sellers in this category as you can check yourself at
https://www.amazon.com/gp/bestsellers/books/3970/ref=pd_zg_hrsr_b_1_5_last#5
As you can check yourself there are 15 just visible now - so 15% - not bad for Forth.
Hugh, you might not know it yet or might have forgotten.
There is a tool like google out there.
Please download it onto your computer or the friends one if you do not own one
and then type in EUROFORTH2018
You will find links like
About 18,700 results (0.32 seconds)
Search Results
Web results
EuroForth 2018 - Complang
www.complang.tuwien.ac.at/anton/euroforth/ef18/
EuroForth 2018. 34nd EuroForth Conference ... EuroForth is an annual conference on the Forth programming language, stack machines, and related topics, and ...
You've visited this page 2 times. Last visit: 16/09/18
EuroForth 2018 proceedings - Complang
www.complang.tuwien.ac.at/anton/euroforth/ef18/papers/
EuroForth 2018 proceedings. You can download the complete proceedings or individual papers and slides. Refereed Papers. Ulrich Hoffmann and Andrew ...
[PDF]EuroForth 2018 - Complang
www.complang.tuwien.ac.at/anton/euroforth/ef18/EuroForth2018-Announcement.pdf
14 Sep 2018 - EuroForth is consistently the best international Forth conference, ... EuroForth 2018 will be held in Scotland in the locale of the ruggedly elegant ...
You've visited this page 2 times. Last visit: 16/09/18
You might never have seen somnething like this
https://wiki.forth-ev.de/doku.php/events:ef2018:start
but as you seem not to be able to search and follow links here you are:
And you can find more there
Chuck Moore Interview
576i camera stream (not my full HD camera), without mic audio video
Friday
13:45 Bernd Paysan — ΜΙΝΩΣ2 GUI, $quid “crypto” video
14:40 Gerald Wodni — redis video
15:20 Andrew Haley — Case video
15:45 Peter Knaggs — A List Toolkit video
16:20 Anton Ertl & Bernd Paysan — Closures — the Forth way video
17:00 Ulrich Hoffmann — Forth, a new synthesis video
Saturday
09:10 Andrew Read & Ulrich Hoffmann — Strings video
09:45 Anton Ertl — Software Vector Chaining video
10:15 Nick Nelson — Dirty Laundry video
11:05 Bill Stoddart — Shor's Algorithm video
11:35 Nick Nelson — 64 Bit Issues video
12:00 Stephen Pelc — Dual Words video
Dinner Party
21:00 Chuck Moore — 50 Years of Forth Speech video
Sunday
09:10 Ulrich Hoffman & Andrew Read — Style Survey video
09:50 Leon Wagner — There's Forth in That video
10:15 Phillip Eaton — Programming in Forth on the Vectrex video
11:00 Gerald Wodni — theForth.net video
11:10 Franck Bensusan (by Anton Ertl) — Method Dispatch in OForth video
11:25 Ulrich Hoffman — Detecting 64 Bit Systems video
peter4...@gmail.com
Apr 13, 2019, 12:47:37 PM4/13/19
to
(that stains the whole forth community
with his nasty words, and absolut lack of any programming knowledge)
still be writing nonsense on CLF ? (like "to download google" f.ex. and
the list continues...)
This is from Google search machine, right now.
"Juergen Pintaske"
it was more teasing and Peter Forth Bullshit - sorry a bad mixture. As you might know I am a STEM Ambassador, and we habe the MeArm demonstratio n in our nexr RPI meeting in December. Mine is as well on the way and hopefully arriving before the event. I had hoped that you would pick up your Forth implementation again - as you had said before. With source Code a nice demonstration of what Forth can do - and expandable for anybody who is interested.an can write Forth.
Manage
LikeShow more reactions
· Reply · 10h
Juergen Pintaske
Juergen Pintaske And please disregard the Peter Forth Bullshit - our local Forth Killer. I rarely came to this group now as I am sick of seeing Peter masturbate - and using one of the books. I have published. actually 10 he can use as in print - I assume such an activity is possibly difficult with a tablet in his hand"
peter4...@gmail.com
Apr 13, 2019, 12:51:21 PM4/13/19
to
On Friday, April 12, 2019 at 10:53:56 AM UTC-3, jpit...@gmail.com wrote:
continues and continues all available on google... (and for those
that have started to download google ...)
Only a part what appears now in Google arround pintaske insults or pintaske swearing , look how this man has thrown everybody in the mudd he lives :
Juergen Pintaske on CLF :
"Forth Killer at work again.
I give a fuck about your disambiguifiers - as I give a fuck about any of your
work you are claiming you have done. It stinks and it always will.
You might flavour it - but shit stays shit.
You give a shit about anybody who does not like you -
which is probably 200% of the Forth community.
Piss off and get out of my thread - who gives you the right to comment here.
You are drunk again or using other drugs.
Never looked at it never will. Why waste my time with it.
An arshole is an arshole -
and only shit comes out of it as you have proven for the last x years"
gnuarm.del...@gmail.com
Apr 13, 2019, 3:43:01 PM4/13/19
to
This is a thread to let be.
--
Rick C.
- Get a 1,000 miles of free Supercharging
- Tesla referral code - https://ts.la/richard11209
hughag...@gmail.com
Apr 13, 2019, 11:12:55 PM4/13/19
to
On Thursday, April 11, 2019 at 8:23:58 PM UTC-7, hughag...@gmail.com wrote:
> Anton Ertl and Bernd Paysan used EuroForth as a platform for attacking
> rquotations, blatantly lying by saying that rquotations don't work.
> Their paper, "Closures --- the Forth Way," was in the refereed section.
>
> Who exactly are these referees that allow blatant lying???
> Do they have names?
> The EuroForth website says:
> "A special "Refereed Section" was introduced with the tenth conference
> in order to make it more attractive to academic institutes."
> How many academic institutes are going to tolerate liars???
Well, I did some googling and found this link:
> Anton Ertl and Bernd Paysan used EuroForth as a platform for attacking
> rquotations, blatantly lying by saying that rquotations don't work.
> Their paper, "Closures --- the Forth Way," was in the refereed section.
>
> Who exactly are these referees that allow blatant lying???
> Do they have names?
> The EuroForth website says:
> "A special "Refereed Section" was introduced with the tenth conference
> in order to make it more attractive to academic institutes."
> How many academic institutes are going to tolerate liars???
http://www.complang.tuwien.ac.at/anton/euroforth/ef18/cfp.html
Anton Ertl is one of the EuroForth referees --- that is why he was able to
get away with lying about rquotations in his EuroForth paper.
This would have worked a lot better if he had had his pocket-boy
Alex McDonald put his name on the paper.
For Anton Ertl to put his own name on the paper when he is a referee
is not going to make EuroForth "more attractive to academic institutes."
hughag...@gmail.com
Apr 14, 2019, 11:38:46 PM4/14/19
to
Rick Collins have to say --- it is always just a stream of insults.
I don't really care much what Peter4 has to say about Juergen Pintaski
being a "latrine mouth" --- I already know about Juergen --- it is off-topic.
I would be interested in hearing what Peter Knaggs has to say
in defense of his linked-list design
(not implementation, because he doesn't have any code).
I said that he lacks a way to remove nodes from the list during traversal.
Moving a node to a different list is going to be a problem for him.
He also has a clumsy design with superfluous words and missing features.
I mostly wanted to slam Peter Knaggs because he is both a Forth-200x
committee member and an MPE employee.
Shining a spotlight on his incompetence is a double-whammy for Stephen Pelc.
Previously I said this:
On Tuesday, February 5, 2019 at 11:04:50 PM UTC-7, hughag...@gmail.com wrote:
> Here is yet another example of Stephen Pelc's dishonesty:
>
> On Sunday, January 27, 2019 at 11:10:14 AM UTC-7, Alex McDonald wrote:
> > On 27-Jan-19 04:06, dxf...@gmail.com wrote:
> > > There is a qualification requirement before one can sit on the Forth
> > > Standards committee?
> >
> > What qualification would you recommend?
> >
> > https://forth-standard.org/standard/members-2x
>
> If we look at that webpage, we find this:
> "Dr. Peter Knaggs (Editor) Independent Member"
>
> But there is Stephen Pelc's webpage:
> https://www.mpeforth.com/sample-page/46-2/
> We find Peter Knaggs listed as an employee of MPE:
> "Peter is the part of the toolmaking team that tells us how to do it properly."
>
> So, an MPE employee is an "independent member" of the Forth-200x committee???
> Forth-200x is really astro-turf --- a corporate marketing gimmick
> faked up to look like a grassroots project.
>
> Similarly, we find Andrew Haley listed:
> "Andrew Haley Red Hat UK Ltd."
> Andrew Haley's Forth experience was to teach the novice-class
> for Forth Inc.. He seems to have no purpose in life except to
> agree with Elizabeth Rather on everything that she says.
> He is not independent either. He is Elizabeth Rather's brown-noser.
>
> Ed (DXForth) asked what qualification requirements are needed
> to sit on the Forth-200x Standard Committee.
> I would recommend a pair of knee-pads and a big bottle of mouthwash.
Now however, I look at that same webpage on the MPE website
and I find that both Juergen Pintaski and Peter Knaggs are missing!
Apparently they got fired!
So, Stephen Pelc coauthored books on Forth with Juergen Pintaski,
then fired him. Stephen Pelc had Peter Knaggs as his "toolmaking team,"
then fired him. Bummer for Juergen Pintaski and Peter Knaggs!
The only employees listed now are Barry Culver and Barto Gillespie.
That is some major down-sizing!
Stephen Pelc is a ruthless boss who is not afraid to swing the axe!
Barto Gillespie should tread carefully, or he'll be going to the dog-pound.
jpit...@gmail.com
Apr 15, 2019, 6:41:53 AM4/15/19
to
Bullshit number 1: MPE had no active involvement in my Forth Bookshelf - except that I published MPE material as well as part of the Forth Bookshelf at
https://www.amazon.co.uk/l/B00N8HVEZM?_encoding=UTF8&redirectedFromKindleDbs=true&rfkd=1&shoppingPortalEnabled=true
And if you check it today - MY book A Start With Forth is actually the featured one. Makes me a bit proud.
Followed by the MPE book, Chuck's book and Tim Hendtlass,
and then the microbit,
that I translated and where I could convince Matthias Koch to implement his mecrisp - find the files at
https://wiki.forth-ev.de/doku.php/en:projects:microbit:start
Bullshit number 2: I worked as a consultant for MPE as I do for other companies - with a new one being added soon.
Everything in life ends at some point, and MPE decided, that my support was not needed at the moment. Fine for me, as it makes time for other projects planned - no hard feelings at all. Actually I can only thank MPE and the owner Stephen Pelc. Actually a working relationship for about 5 years. Quite long actually.
Hugh Idiot, Bullshit number 3: You attack anybody here you can find suitable, if you would be visible as a real person somewhere,
I assume there would be a few "friendly" discussions.
And Hugh Idiot, as even you have realized now that I do not have to restrict my opinion about your bullshit, you will probably find more comments from now on, if I find the time.
And before you get excited about the VEEEERY high book price at amazon
https://www.amazon.com/BBC-Micro-Tests-Tricks-Secrets/dp/1541200721
this book is in transition from Burkhard to me, so I can add in the Forth pages and it will be a joint edition.
The real price is now life again at
https://www.amazon.com/dp/1092154272
the new eBook to follow when I have time.
hughag...@gmail.com
Apr 28, 2019, 2:07:28 PM4/28/19
to
On Monday, April 8, 2019 at 11:26:32 PM UTC-7, hughag...@gmail.com wrote:
> I read through Peter Knaggs paper on lists:
> http://www.complang.tuwien.ac.at/anton/euroforth/ef18/papers/knaggs.pdf
>
> His FOREACH I NEXT fail badly because they don't allow the
> item to be removed from the list during the traversal, such
> as by inserting it into a different list.
> Doing this would cause NEXT to return a corrupted value
> (in a linked list, because the link has been changed).
> The FOREACH traversal would go haywire! As they say at MPE: "Oops!"
>
> Does he not know that the word I is already used in DO loops???
In Peter Knaggs' paper, he says this about his FOREACH word:
> http://www.complang.tuwien.ac.at/anton/euroforth/ef18/papers/knaggs.pdf
>
> His FOREACH I NEXT fail badly because they don't allow the
> item to be removed from the list during the traversal, such
> as by inserting it into a different list.
> Doing this would cause NEXT to return a corrupted value
> (in a linked list, because the link has been changed).
> The FOREACH traversal would go haywire! As they say at MPE: "Oops!"
>
> Does he not know that the word I is already used in DO loops???
--------------------------------------------------------------------
Run-time: ( list –– ) ( R: –– iter ) Initialise an iteration over the list,
placing the iteration control (iter) onto the return stack.
--------------------------------------------------------------------
He clearly states that the only datum he is holding on the return-stack
is the "iter" (meaning the current node in the list).
He is failing to hold the next node in the list!!!
If the current node gets modified, such as being moved to another list,
then the link to the next node will be corrupted. NEXT will go haywire.
This is gross incompetence!
Peter Knaggs can't fix this bug, because he has already done his
little EuroForth victory-dance, effectively writing his bug-ridden
design in stone. He can't fix it later without looking stupid!
In his EuroForth victory-dance, he was asked about early exit
from a list traversal.
He said: "That is possible."
Really??? How would he know what is possible or not?
Maybe he had a dream about a future implementation with this feature.
When he was asked about providing an implementation,
he said: "That is the plan!"
Shouldn't this plan be completed before doing the EuroForth victory-dance?
I can prevent Peter Knaggs from completing this plan.
I just post working code here (that I wrote in 2009).
After I do this, he will have to figure out a different way to implement
his linked lists --- otherwise I will accuse him of copying my code.
So, by providing the Forth-200x committee member with working code,
I am NOT providing Forth-200x with a path to success.
Exactly the opposite --- I am denying Forth-200x a path to success.
I want Forth-200x to be discredited, and totally fail.
I will block every possible path to success that they may reach for.
This is working code:
--------------------------------------------------------------------
SwiftForth? [if]
icode next>r ( node -- node ) \ r: -- next-node
0 [ebx] push
ret end-code
[else]
macro: next>r ( node -- node ) \ r: -- next-node
dup .fore @ >r ;
[then]
macro: each[ \ toucher: i*x node -- j*x
begin dup while
next>r ;
macro: ]each
r> repeat drop ;
\ EACH[...]EACH generates faster-executing code than EACH, and can be more readable, but the code is more bloated.
\ EACH[...]EACH uses the return stack. This can create havoc in functions that use locals or use >R and R>.
\ EACH[...]EACH is mostly only used when speed is important, which largely precludes locals anyway.
\ FIND-NODE and FIND-PRIOR can't be written like this because they both involve an early-out.
\ EACH allows the toucher (the code that touches the node) to be tested on its own, and also to be used on its own.
\ EACH also allows the toucher to use local variables.
\ Both of these advantages can be achieved with EACH[...]EACH by factoring the toucher into a function and calling it.
\ EACH can easily be rewritten in assembly language, which might not be true of EACH[...]EACH.
\ Because of these reasons, EACH should generally be used rather than EACH[...]EACH.
SwiftForth? [if]
icode each ( i*x head 'toucher -- j*x ) \ toucher: i*x node -- j*x
ebx push [drop] \ -- node \r: -- 'toucher
begin non-zero? while
0 [ebx] push \ -- node \r: -- 'toucher next
w [esp] eax mov edi eax add eax call \ --
[dup] ebx pop \ -- next \r: -- 'toucher
repeat
[drop] [rdrop] ret end-code
[else]
: each ( i*x head 'toucher -- j*x ) \ toucher: i*x node -- j*x
>r
begin dup while \ -- node \r: -- 'toucher
r@ over .fore @ >r \ -- node 'toucher \r: -- 'toucher next
execute r> repeat drop
rdrop ;
[then]
\ It is possible for the toucher to access data underneath the node,
\ as EACH has no internal data on the stack (that is why we put everything on the return stack during the EXECUTE).
\ It is ok for the toucher to REMOVE the node from this list,
\ as we already have our next node on the r-stack.
\ When writing a filter, you REMOVE all of the nodes that you don't want to keep.
\ The toucher shouldn't remove multiple nodes however,
\ as it might clobber the next-node that EACH has waiting on the r-stack.
SwiftForth? [if]
code find-node ( i*x head 'toucher -- j*x node|false ) \ toucher: i*x node -- j*x flag
ebx push [drop] \ -- node \r: -- 'toucher
begin non-zero? while
0 [ebx] push ebx push \ -- node \r: -- 'toucher next node
w 2* [esp] eax mov edi eax add eax call \ --
non-zero? if ebx pop [2rdrop] ret then
[rdrop] ebx pop
repeat
[rdrop] ret end-code
[else]
: find-node ( i*x head 'toucher -- j*x node|false ) \ toucher: i*x node -- j*x flag
>r
begin dup while \ -- node \r: -- toucher
r@ over .fore @ >r over >r \ -- node toucher \r: -- toucher next node
execute if r> 2rdrop exit then \ return node
rdrop r> repeat \ -- next \r: -- toucher
rdrop ; \ return the node, which is NIL (FALSE) by now
[then]
\ FIND-NODE is like EACH except that it stops when the toucher returns true,
\ and it either returns the found node or false
variable comparisons \ used for testing purposes, to count how many comparisons are done
\ COMPARISONS needs to be zero'd prior to your sort executing.
\ COMPARISONS is incremented in FIND-PRIOR used in <SORT-LIST> and in SORT-LIST too.
SwiftForth? [if]
code find-prior ( i*x head 'toucher -- j*x -1|node|false ) \ toucher: i*x node -- j*x flag
ebx push [drop] \ -- node \ r: -- 'toucher
-1 # push \ r: -- 'toucher prior \ prior is -1
begin non-zero? while
comparisons inc
0 [ebx] push ebx push \ -- node \ r: -- 'toucher prior next node
w 3 * [esp] eax mov edi eax add eax call \ -- flag
non-zero? if [2rdrop] ebx pop [rdrop] ret then
eax pop ebx pop [rdrop] eax push
repeat
[2rdrop] ret end-code
[else]
: find-prior ( i*x head 'toucher -- j*x -1|node|false ) \ toucher: i*x node -- j*x flag
>r -1 >r \ prior is -1, meaning found node was the head
begin dup while \ -- node \r: -- 'toucher prior
1 comparisons +!
rr@ over .fore @ >r over >r \ -- node toucher \r: -- 'toucher prior next node
execute if 2rdrop r> rdrop exit then \ return prior
2r> rdrop >r repeat \ -- next \r: -- 'toucher node
2rdrop ; \ return the node, which is NIL (FALSE) by now
[then]
\ FIND-PRIOR is like FIND-NODE except that it returns the node prior to the found node,
\ or -1 if the found node was the head --- or false if no node was found.
--------------------------------------------------------------------
I actually have quite a lot more code than this,
but these are the basic traversal HOFs.
hughag...@gmail.com
May 3, 2019, 10:31:59 PM5/3/19
to
On Tuesday, April 9, 2019 at 8:31:04 PM UTC-7, hughag...@gmail.com wrote:
> 3.) This code filters out all of the nodes
> with a value < 0.5 and put them in a different list.
> -------------------------------------------------------------------
> : <test3> ( sml-head big-head node -- )
> init-list \ the node is going to another list
> dup .real f@ 0.5e f< if swap >r link r> \ link to SML-HEAD
> else link then ; \ link to BIG-HEAD
>
> : test3 ( head -- sml-head big-head ) \ filter small nodes (<0.5) into SML-HEAD
> nil nil rot ['] <test3> each ;
> -------------------------------------------------------------------
> Peter Knaggs will fail on writing TEST3 because INIT-LIST changes
> the link field of the node so NEXT won't work.
Here is an alternate way to do this:
> 3.) This code filters out all of the nodes
> with a value < 0.5 and put them in a different list.
> -------------------------------------------------------------------
> : <test3> ( sml-head big-head node -- )
> init-list \ the node is going to another list
> dup .real f@ 0.5e f< if swap >r link r> \ link to SML-HEAD
> else link then ; \ link to BIG-HEAD
>
> : test3 ( head -- sml-head big-head ) \ filter small nodes (<0.5) into SML-HEAD
> nil nil rot ['] <test3> each ;
> -------------------------------------------------------------------
> Peter Knaggs will fail on writing TEST3 because INIT-LIST changes
> the link field of the node so NEXT won't work.
-------------------------------------------------------------------
: mtest3 ( head -- sml-head big-head ) \ filter small nodes (<0.5) into SML-HEAD
nil nil rot each[ <test3> ]each ;
-------------------------------------------------------------------
This is slightly faster.
I don't like using EACH[ ... ]EACH though because they
use the return-stack which is confusing for the user
who may be using the return stack for something else.
In general, EACH should be used.
It occurs to me that Peter Knaggs might try to fix the bug
in his FOREACH ... NEXT design and then pretend that he
noticed the bug himself, and didn't need me to point out the bug.
I can prevent him from doing this by posting code here that fixes
his bug. He can't use this code because he would be copying me.
So, I have blocked his path to success!
Here is the code:
-------------------------------------------------------------------
macro: foreach ( node -- ) \ r: -- next-node node \ use R@ inside to access node
begin dup while
next>r >r ;
macro: next ( -- )
rdrop r> repeat drop ;
-------------------------------------------------------------------
Here is a test of the code:
-------------------------------------------------------------------
: ftest3 ( head -- sml-head big-head ) \ filter small nodes (<0.5) into SML-HEAD
nil nil rot foreach r@ <test3> next ;
-------------------------------------------------------------------
I don't recommend my FOREACH ... NEXT though, because this is less
efficient than my EACH[ ... ]EACH that I already have:
-------------------------------------------------------------------
SwiftForth? [if]
icode next>r ( node -- node ) \ r: -- next-node
0 [ebx] push
ret end-code
[else]
macro: next>r ( node -- node ) \ r: -- next-node
dup .fore @ >r ;
[then]
macro: each[ \ toucher: i*x node -- j*x
begin dup while
next>r ;
macro: ]each
r> repeat drop ;
-------------------------------------------------------------------
SwiftForth? [if]
icode next>r ( node -- node ) \ r: -- next-node
0 [ebx] push
ret end-code
[else]
macro: next>r ( node -- node ) \ r: -- next-node
dup .fore @ >r ;
[then]
macro: each[ \ toucher: i*x node -- j*x
begin dup while
next>r ;
macro: ]each
r> repeat drop ;
Peter Knaggs offended me by prancing around at EuroForth
hee-hawing about how he is the world's expert on linked-lists in Forth.
He deserves to be pilloried for his failure to design a linked-list
system in Forth that could work, and his failure to implement his
linked-list system with actual code
(maybe if he had written code to implement his design,
he would have realized that the design didn't work --- do you think?).
I want Peter Knaggs to be shamed into resigning from the Forth-200x
committee on the basis that he is incompetent at Forth.
All of the Forth-200x committee members should resign for the same reason.
I am not going to accept the Forth-200x committee as my leader!
Nobody should!
dxf...@gmail.com
May 3, 2019, 11:23:38 PM5/3/19
to
On Saturday, 4 May 2019 12:31:59 UTC+10, hughag...@gmail.com wrote:
> ...
staged spectacles there's little reason to attend.
> ...
> All of the Forth-200x committee members should resign for the same reason.
> I am not going to accept the Forth-200x committee as my leader!
> Nobody should!
200x is but one of the Euroforth events. Unless you're attracted to
> I am not going to accept the Forth-200x committee as my leader!
> Nobody should!
staged spectacles there's little reason to attend.
hughag...@gmail.com
May 5, 2019, 2:12:07 AM5/5/19
to
On Sunday, April 28, 2019 at 11:07:28 AM UTC-7, hughag...@gmail.com wrote:
> In Peter Knaggs' paper, he says this about his FOREACH word:
> --------------------------------------------------------------------
> Run-time: ( list –– ) ( R: –– iter ) Initialise an iteration over the list,
> placing the iteration control (iter) onto the return stack.
> --------------------------------------------------------------------
> He clearly states that the only datum he is holding on the return-stack
> is the "iter" (meaning the current node in the list).
> He is failing to hold the next node in the list!!!
> If the current node gets modified, such as being moved to another list,
> then the link to the next node will be corrupted. NEXT will go haywire.
> This is gross incompetence!
I looked at Peter Knaggs' description of TRAVERSE-LIST that is similar
> In Peter Knaggs' paper, he says this about his FOREACH word:
> --------------------------------------------------------------------
> Run-time: ( list –– ) ( R: –– iter ) Initialise an iteration over the list,
> placing the iteration control (iter) onto the return stack.
> --------------------------------------------------------------------
> He clearly states that the only datum he is holding on the return-stack
> is the "iter" (meaning the current node in the list).
> He is failing to hold the next node in the list!!!
> If the current node gets modified, such as being moved to another list,
> then the link to the next node will be corrupted. NEXT will go haywire.
> This is gross incompetence!
to my EACH word --- he screwed this up too!
He says:
"The xt is executed once for each element in the list,
with each element being presented to the xt on the top of the stack (x)."
Notice that he says each element is presented to the pseudo-quotation.
He doesn't present each element's address, so the element can't be
changed; it is read-only. This is gross incompetence!
If I were a high-school AP Forth-programming teacher,
I would consider implementing a linked-list to be a reasonable
assignment for the students (a self-balancing binary tree might be
too difficult). I would use the following criteria for grading:
F (0 pts) --- The student doesn't design a linked-list system and no code
is written. The student just does a vague hand-waving argument
claiming that he or she can do anything and everything easily,
and it will be super-duper, but it will be application-specific:
"...in Forth it's so easy to build data structures that are exactly right
for the particular application at hand that worrying about what pre-built
structures you have and how to use them is just not worth the bother."
D (1 pt) --- The student designs a linked-list system,
but it has gross bugs so it will not work if implemented.
No code is written.
C (2 pt) --- The student designs a linked-list system that would work.
Some Forth code is written, but it is incomplete and/or has bugs.
B (3 pt) --- The student designs a linked-list system that would work.
Some Forth code is written; it is reasonably complete, and it works.
A (4 pt) --- The 'B' result, plus:
All of the important code is also written in SwiftForth assembly
to work around the lack of compiler-optimization in SwiftForth.
extra-credit (5 pt) ---
The student invents rquotations and implements them, so the rquotation
can access the parent function's local variables despite the HOF
having local variables of its own.
The 'B' result is done using rquotations and REX rather than EXECUTE
so the HOFs can be written using local variables rather than the
return-stack, and the rquotations use the parent's local variables.
The student knows enough about the C language to explain how rquotations
succeed at providing Forth with a feature that ANSI-C lacks (GCC has though).
Within this grading system, Peter Knaggs would get a 'D' ---
which is a step up from Elizabeth Rather, who gets an 'F'.
Of course, there is no such thing as an AP Forth-programming class.
Forth is considered to be utterly retarded, thanks to ANS-Forth.
A school offering an AP class in Forth programming would be comparable
to a school offering an AP class in "traditional dance" ---
parents would complain --- really, this turkey is not going to fly!
I looked up Peter Knaggs website: http://www.rigwit.co.uk/about/jobs.html
There is no indication that he has ever written any Forth code.
His work experience is typical web programming (JavaScript etc.) ---
he has never been a Forth programmer!
He was on the ANS-Forth committee, so he is blame-worthy for that failure.
He should resign from the Forth-200x committee because he is incompetent.
I predict that Peter Knaggs will never succeed at implementing
a linked-list that works reasonably well (a 'B' grade in high-school).
If he copies my code, that doesn't count as a success for him!
Copying somebody else's code will get a high-school student expelled...
foxaudio...@gmail.com
May 5, 2019, 9:35:40 AM5/5/19
to
On Sunday, May 5, 2019 at 2:12:07 AM UTC-4, hughag...@gmail.com wrote:
> I looked up Peter Knaggs website: http://www.rigwit.co.uk/about/jobs.html
> There is no indication that he has ever written any Forth code.
> His work experience is typical web programming (JavaScript etc.) ---
> he has never been a Forth programmer!
> He was on the ANS-Forth committee, so he is blame-worthy for that failure.
> He should resign from the Forth-200x committee because he is incompetent.
>
Check out some of the other tabs on the site. Peter is an academic of some note in the area
> I looked up Peter Knaggs website: http://www.rigwit.co.uk/about/jobs.html
> There is no indication that he has ever written any Forth code.
> His work experience is typical web programming (JavaScript etc.) ---
> he has never been a Forth programmer!
> He was on the ANS-Forth committee, so he is blame-worthy for that failure.
> He should resign from the Forth-200x committee because he is incompetent.
>
of Forth technology. His work provides us with some real data on how Forth compares with
other programming methods.
Examples:
1994 Ph.D.
Thesis entitled "Theoretical and Practical Aspects of Forth Software Development". The research was undertaken at the University of Teesside during 1988-1992, with the thesis being completed in 1994. Now available for download.
1988 PGD
Polytechnic Graduate Diploma in Computer Studies (Software Engineering), 1987 to 1988 at Teesside Polytechnic, passed with Distinction.
Personal Project 32 Bit Forth on OS-9/68000
dxf...@gmail.com
May 5, 2019, 8:26:59 PM5/5/19
to
On Sunday, 5 May 2019 23:35:40 UTC+10, foxaudio...@gmail.com wrote:
> ...
other academics to read. It's all very 'other' worldly. Forth has
largely avoided (or perhaps antagonised) academia for them to take
it seriously. Standards was the net to bag and tag Forth but like
Chuck it has evaded capture and continues to run wild.
> ...
> Check out some of the other tabs on the site. Peter is an academic of some note in the area
> of Forth technology. His work provides us with some real data on how Forth compares with
> other programming methods.
OTOH academics tend to write papers about what others have done for
> of Forth technology. His work provides us with some real data on how Forth compares with
> other programming methods.
other academics to read. It's all very 'other' worldly. Forth has
largely avoided (or perhaps antagonised) academia for them to take
it seriously. Standards was the net to bag and tag Forth but like
Chuck it has evaded capture and continues to run wild.
hughag...@gmail.com
May 5, 2019, 10:17:39 PM5/5/19
to
On Sunday, May 5, 2019 at 6:35:40 AM UTC-7, foxaudio...@gmail.com wrote:
> On Sunday, May 5, 2019 at 2:12:07 AM UTC-4, hughag...@gmail.com wrote:
>
> > I looked up Peter Knaggs website: http://www.rigwit.co.uk/about/jobs.html
> > There is no indication that he has ever written any Forth code.
> > His work experience is typical web programming (JavaScript etc.) ---
> > he has never been a Forth programmer!
> > He was on the ANS-Forth committee, so he is blame-worthy for that failure.
> > He should resign from the Forth-200x committee because he is incompetent.
> >
>
> Check out some of the other tabs on the site. Peter is an academic of some note in the area
> of Forth technology. His work provides us with some real data on how Forth compares with
> other programming methods.
Being an "academic" doesn't at all imply that he has ever written
> On Sunday, May 5, 2019 at 2:12:07 AM UTC-4, hughag...@gmail.com wrote:
>
> > I looked up Peter Knaggs website: http://www.rigwit.co.uk/about/jobs.html
> > There is no indication that he has ever written any Forth code.
> > His work experience is typical web programming (JavaScript etc.) ---
> > he has never been a Forth programmer!
> > He was on the ANS-Forth committee, so he is blame-worthy for that failure.
> > He should resign from the Forth-200x committee because he is incompetent.
> >
>
> Check out some of the other tabs on the site. Peter is an academic of some note in the area
> of Forth technology. His work provides us with some real data on how Forth compares with
> other programming methods.
any Forth code. How is he going to provide "real data" without
actually writing any code?
His description of TRAVERSE-LIST says this:
--------------------------------------------------------------
Comments: This is known as map or each in other languages.
Formally: ∀x∈list•xt(x)
--------------------------------------------------------------
This is super-duper academic! He is even using math symbols! Woo hoo!
It is all B.S. though. As I pointed out, he failed in that his
TRAVERSE-LIST provides the pseudo-quotation with the datum,
not the address of the datum, so his data is read-only.
A real programmer would not make such a novice-level mistake.
He says this:
--------------------------------------------------------------
The words have been defined in a way that does not require any particular implementation, thus allowing the developer to use the most appropriate implementation method for there system. For example:
Array ...
Linked List ...
Array List ...
Bucket List ...
--------------------------------------------------------------
This is more B.S.. He seems to believe that he has a mandate to
define behavior rather than implementation, but his solution is
impractical. He should just figure out how to implement a linked-list.
A linked-list could be *simulated* with an
array, but this is not a linked-list. Performance will be abysmal!
He doesn't seem to understand OOP.
In my system, the implementation of the linked-list is hidden
because the .FORE field is part of the LIST class and the
user doesn't access it --- the user who implements a child class
uses functions in the LIST class that internally access the .FORE field.
I have LINK DELINK REMOVE LENGTH TAIL NTH etc. available for the user.
I think he is a fake. He has no practical experience with Forth.
He spouts a lot of pseudo-intellectual blather that has nothing to do
with writing Forth programs. He makes novice-level design mistakes.
> Examples:
>
> 1994 Ph.D.
> Thesis entitled "Theoretical and Practical Aspects of Forth Software Development". The research was undertaken at the University of Teesside during 1988-1992, with the thesis being completed in 1994. Now available for download.
>
> 1988 PGD
> Polytechnic Graduate Diploma in Computer Studies (Software Engineering), 1987 to 1988 at Teesside Polytechnic, passed with Distinction.
>
> Personal Project 32 Bit Forth on OS-9/68000
seriously than DXForth for the Z80 running under CP/M?
This is not professional Forth. This is hobbyist Forth.
This is not comparable to my MFX that was used to write a motion-control
program for the MiniForth that provided better performance and lower cost
than the competitor's MC68000 board programmed in C.
He also says this about his other hobby:
"The dancers wear dozens of bells on each leg,
wield sticks and/or handkerchiefs, and dance to lively folk tunes."
Why is he telling us this stuff???
His failure to implement a linked-list tells me all that I need
to know about him. This is all that anybody needs to know about Forth-200x.
hughag...@gmail.com
May 6, 2019, 12:39:56 AM5/6/19
to
On Sunday, May 5, 2019 at 5:26:59 PM UTC-7, dxf...@gmail.com wrote:
> Standards was the net to bag and tag Forth but like
> Chuck it has evaded capture and continues to run wild.
Here are some more DXForth quotes:
> Standards was the net to bag and tag Forth but like
> Chuck it has evaded capture and continues to run wild.
On Saturday, May 4, 2019 at 8:36:02 PM UTC-7, dxf...@gmail.com wrote:
> On Saturday, 4 May 2019 13:27:17 UTC+10, hughag...@gmail.com wrote:
> > A viable Forth Standard is what Forth still needs in 2019.
> > Before this can happen, Forth-83, ANS-Forth and Forth-200x all
> > need to be flushed.
> > [...]
> > start over from scratch!
>
> Since you mention Chuck, his view is that Forth should be small
> enough to throw away and start over from scratch. No room for
> standards or empire-building there.
On Friday, April 26, 2019 at 7:36:33 AM UTC-7, dxf...@gmail.com wrote:
> On Friday, 26 April 2019 21:00:58 UTC+10, hughag...@gmail.com wrote:
> > DXForth endlessly says that a Forth standard imposes arbitrary limits.
> > This isn't true though.
> > Only Elizabeth Rather's Forth standards (Forth-83, ANS-Forth and Forth-200x)
> > impose arbitrary limits. A Forth standard designed by a programmer
> > would be adequate for writing programs. There may still be cases
> > in which the standard needs to be abandoned, but this should be
> > less than 5% of the time. The standard should be good for mundane programs.
>
> I think you mean writing a program from mundane components written
> by somebody else. The chances of my doing that are the same yours.
> Neither of us have any interest in being subservient. When FIG the
> organization died for lack of newcomers to lead, so too its creation
> the Forth standards for the same reason.
DXForth endlessly says that Forth Standards will limit what Forthers
can do, and will capture them in a net so they can't run wild,
and will make them all subservient, and are all about empire-building.
This is very repetitive!
This is also not true.
Such repetitive untruth gets on my nerves...
The purpose of a Forth Standard is to allow programs to be portable
between Forth systems and (more importantly) to allow code-libraries
to be portable between Forth systems (making code-libraries widely useful).
I'm not trying to limit Forthers' awesome creativity and capture them in a net.
I'm saying that 95% of programs don't need awesome creativity,
but they need to be written quickly and be bug-free,
which is what code-libraries make easy.
If people want to exercise their awesome creativity, micro-controllers
would be a good place to do this. I don't expect a standard
to ever be available for micro-controller programming.
They can also break with the standard in the few programs that require this.
Designing a linked-list for Forth-200x is not the best way to be creative.
A linked-list is trivial to design and implement. I did this a decade ago.
A Standard should cover basic low-level support-code such as this.
The Forther is freed to exercise his creativity on something interesting.
I think that DXForth is somewhat over-impressed by his own creativity.
He expects his customized linked-list to be super-duper compared to mine.
This isn't true. My LIST.4TH is more than adequate for anybody.
It is a waste of time to get bogged down in linked-list design in the
year 2019 --- this is high-school level programming --- it has been done.
DXForth is very focused on evading capture and continuing to run wild.
How well has that plan worked out? He is working under CP/M that is obsolete.
There needs to be less emphasis on being a free-spirit and more
emphasis on writing programs that do something reasonably useful.
It is weirdly ironic that DXForth is saying essentially the same thing that
Elizabeth Rather is saying:
"...in Forth it's so easy to build data structures that are exactly right
for the particular application at hand that worrying about what pre-built
structures you have and how to use them is just not worth the bother."
She endlessly says that writing every program from scratch results
for the particular application at hand that worrying about what pre-built
structures you have and how to use them is just not worth the bother."
in code that is "exactly right" and super-optimized for that program.
This isn't true.
Ad hoc programming results in inefficient code because the programmer
doesn't have time to write super-optimized code. No boss allots time
for implementing a HeapSort or a self-balancing binary-tree.
The boss just wants the application program written quickly and bug-free.
If a programmer needs sorted data, he is likely to implement a BubbleSort
for an array or a non-balanced binary-tree because this can be done
in minutes from memory (no need to reach for a heavy tome on algorithms).
This is weirdly ironic because Elizabeth Rather was the driving force
behind Forth-83, ANS-Forth and Forth-200x (DXForth was wrong when he
said that FIG was the creator of the Forth standards and that this was
done for the the purpose of leading newcomers).
The reason why ANS-Forth failed was that it was a marketing gimmick
from Forth Inc., with the purpose of making LMI's UR/Forth non-standard
and convincing the world that Forth Inc. sets the standard for Forth.
It was not designed for the purpose of allowing code portability.
Forth-200x is failing for the same reason.
Forth-200x is a marketing gimmick from MPE though; Forth Inc. is fading away.
Stephen Pelc is opposed to code portability because of the obvious
implication that there must be more than one Forth system that Forth code
is portable between, but he wants VFX to be the one and only Forth system.
Rabican
May 6, 2019, 8:52:52 AM5/6/19
to
hughag...@gmail.com
May 6, 2019, 3:43:14 PM5/6/19
to
On Monday, May 6, 2019 at 5:52:52 AM UTC-7, Rabican wrote:
> On Tuesday, April 9, 2019 at 2:26:32 AM UTC-4, hughag...@gmail.com wrote:
> > All in all, I think that Peter Knaggs made a fool of himself
> > publicly by writing this EuroForth paper.
> > He is pretending to be an expert on a subject that he knows nothing
> > about. He also has refused to provide source-code ---
> > most likely, because all he has produced so far is a bug-ridden mess.
>
> expose those bums!!
> On Tuesday, April 9, 2019 at 2:26:32 AM UTC-4, hughag...@gmail.com wrote:
> > All in all, I think that Peter Knaggs made a fool of himself
> > publicly by writing this EuroForth paper.
> > He is pretending to be an expert on a subject that he knows nothing
> > about. He also has refused to provide source-code ---
> > most likely, because all he has produced so far is a bug-ridden mess.
>
You are a bum too, Gavino!
You endlessly ask if Forth can do some application in 1% of the code
and 100x the performance, but you don't provide any source-code.
How is this different than Peter Knaggs claiming to be an expert on
linked-lists, but not providing any source-code?
How is this different than Andrew Haley claiming to be an expert on
SWITCH using a perfect hash function, but not providing any source-code?
How is this different from Elizabeth Rather making statements like this:
------------------------------------------------------------------------
Virtually every Forth application needs some kind of array structures.
The reason that some general-purpose one might be "little used"
is because it's so easy to make a version that does *exactly* what the
application needs rather than some generic definition. ...
The objective is to master the toolset and be able to think clearly
about exactly what kind of arrays will be useful in your application
and then build exactly that kind.
------------------------------------------------------------------------
She is claiming that Forth Inc. code will be *exactly* what is needed
for a particular application, unlike my general-purpose array structure.
All you have to do is hire Forth Inc. to write an application, and pay
them up front, and then the super-duper will begin!
Realistically, she doesn't know how to implement a general-purpose array
structure. The "Starting Forth" book provided code for a single-dimension
array of cells, so that is all that she knows.
She might even be able to write a two-dimensional array of cells
(I don't remember if "Starting Forth" had this or not).
Her employee Andrew Haley attempted to write a general-purpose array
structure, and he did succeed in allowing for any number of dimensions,
but it was still just an array of cells, so it wasn't general-purpose.
I upgraded this to allow for any size of array element,
which became my ARY definer in the novice-package.
Similarly, Wil Baden wrote an array-sort function, but it was limited
to an array of cells, so it wasn't general-purpose, which my SORT is.
AFAIK, Wil Baden was an employee of Forth Inc. too.
hughag...@gmail.com
May 6, 2019, 4:16:28 PM5/6/19
to
On Monday, April 8, 2019 at 11:26:32 PM UTC-7, hughag...@gmail.com wrote:
> His word set is too big. I have LINK and DELINK , whereas he has:
> LIST+ LIST- +LIST -LIST CONCAT >LIST LIST>
> All of this is trivially done with LINK and DELINK in my LIST.4TH.
Well, since I have been bragging up DELINK , I looked at it.
> LIST+ LIST- +LIST -LIST CONCAT >LIST LIST>
> All of this is trivially done with LINK and DELINK in my LIST.4TH.
I realized that it depends on FIND-PREV and FIND-PREV can be made faster.
This is what I had:
-------------------------------------------------------------------------
: <find-prev> ( targ node -- targ ? )
.fore @ over = ;
: find-prev ( head node -- prev ) \ finds the node prior to node; nil if node = head
dup 0= if nip exit then
[ safe? ] [if] 2dup in-list? 0= abort" *** FIND-PREV node not found ***" [then]
swap ['] <find-prev> find-node nip ;
-------------------------------------------------------------------------
This is the new version:
-------------------------------------------------------------------------
\ This is a new version that is faster, and does error-checking even without SAFE? being set.
: find-prev ( head node -- prev ) \ finds the node prior to node; nil if node = head
dup 0= if nip exit then
nil rot begin dup while \ -- targ-node prev-node current-node
rover over = if drop nip exit then \ if TARG = CURRENT then return PREV as our result
nip dup .fore @ \ -- targ-node current-node next-node
repeat
true abort" *** FIND-PREV node not found ***" ;
-------------------------------------------------------------------------
This is an example of how I originally used a general-purpose function
(the FIND-NODE in the first example), and then rewrote this manually
for improved speed. This is the correct way to do it.
I write code first using general-purpose code-library functions for
convenience. Then, if I think speed is important, I rewrite a customized
version. This is the exact opposite of what Elizabeth Rather recommends.
She says to write the customized version first, and then upgrade it
to be general-purpose (this never works; it doesn't become general-purpose).
Peter Knaggs seems to think that an array can be used to simulate
a linked list, and this will make functions such as FIND-PREV and TAIL etc.
faster, because they won't have to do a sequential search.
This isn't really true though.
These sequential-search functions are very small tight loops.
On an x86, the entire function gets translated into trace-code and
executed --- this is very fast, even with thousands of elements.
These are some more sequential functions that I have had since 2009:
-------------------------------------------------------------------------
SwiftForth? [if]
icode length ( head -- count )
zero(eax)
begin non-zero? while [@] eax inc repeat
eax ebx mov ret end-code
[else]
: length ( head -- count )
0 0 do
dup 0= if I nip unloop exit then
.fore @ loop ;
[then]
: length? ( head count -- flag ) \ is the list at least COUNT in length?
swap 0 0 do \ -- count node
over I = if 2drop true unloop exit then
dup 0= if 2drop false unloop exit then
.fore @ loop ;
char & comment
: tail ( head -- node )
begin dup .fore @ dup while \ -- node next
nip repeat drop ;
\ This version of TAIL doesn't optimize very well because some code is in front of the WHILE and some after the WHILE.
&
SwiftForth? [if]
icode tail ( head -- node )
zero(eax) \ eax is the previous node (initialized to NIL)
begin non-zero? while ebx eax mov [@] repeat
eax ebx mov ret end-code
[else]
: tail ( head -- node )
nil swap begin dup while \ -- prev node
nip dup .fore @ repeat drop ;
\ This version of TAIL should optimize fairly well because the NIP and the DUP are adjacent.
\ SwiftForth doesn't do any peephole optimization, but a more professionally written Forth should be able to combine these.
[then]
: big-nth ( head n -- node ) \ N is an index as for an array \ returns nil if N is >= to the length
0 ?do
.fore @ dup 0= if unloop exit then
loop ;
: small-nth ( head n -- node ) \ N is an index as for an array \ returns nil if N is >= to the length
begin dup while
over 0= if drop exit then
swap .fore @ swap 1- repeat drop ;
\ BIG-NTH is faster with large values of N; there is more up-front overhead but less work per node.
\ SMALL-NTH is faster with small values of N; there is less up-front overhead but more work per node.
SwiftForth? [if]
icode nth ( head n -- node )
ebx eax mov [drop]
begin eax eax or 0<> while
zero? if ret then
[@] eax dec repeat
ret end-code
[else]
get-current synonym nth big-nth ( head n -- node ) \ N is an index as for an array \ returns nil if N is >= to the length
[then]
-------------------------------------------------------------------------
Note that by posting this code, I am blocking Peter Knaggs from using it.
If he uses it, then he is copying me, which I will object to.
A big Forth-200x committee member shouldn't have to copy my code,
especially considering that Stephen Pelc (committee chair-person)
is committed to saying that I am utterly incompetent at Forth programming.
My purpose here is to discredit the Forth-200x committee.
I am not providing them with a path to success.
I want them to be shamed into giving up on Forth,
because they are making a negative contribution to Forth.
hughag...@gmail.com
May 17, 2019, 1:35:42 AM5/17/19
to
On Thursday, May 16, 2019 at 12:59:20 PM UTC-7, Gerry Jackson wrote:
> On 16/05/2019 12:44, Rick C wrote:
> > Sometimes I wish people would just stop replying to him.
> > Just like most trolls, if no one replies to him he will stop posting.
> > But sooner or later there is someone who engages with him because
> > he is just so outrageous and that is enough to keep him coming back.
> > Many times people say they have to post so new comers will know
> > he is a whack job and not listen to him. lol
> > Better he posts his whack and no one replies... that is a HUGE flag.
>
> The nearest we got to this was his disgraceful post about Peter Knaggs
> which was mostly ignored and, to keep it live, Hugh was reduced to
> replying to himself several times.
>
> --
> Gerry
Peter Knaggs disgraced the Forth community by going to EuroForth-2018
and claiming to be the world's expert on Forth linked-lists, and
solely qualified to set the Standard for the entire Forth community.
Peter Knaggs wants Forth programmers such as myself to get on our knees
and tell him that he is their leading expert who sets the Standard for them.
He was unable to get his code debugged, so he went without any code.
His design was a muddled mess containing multiple novice-level
blunders. If he were a high-school student, he would get a 'D' for this.
Peter Knaggs should resign from the Forth-200x committee because
he is too incompetent to implement a linked-list,
which is really high-school level programming.
Gerry Jackson is a sycophant of the Forth-200x committee.
This is why he gives Peter Knaggs 100% support for his EuroForth-2018
presentation, which I assume will be in Forth-200x soon (it may have
already gone through the CfV and been written in stone in Forth-200x).
> On 16/05/2019 12:44, Rick C wrote:
> > Sometimes I wish people would just stop replying to him.
> > Just like most trolls, if no one replies to him he will stop posting.
> > But sooner or later there is someone who engages with him because
> > he is just so outrageous and that is enough to keep him coming back.
> > Many times people say they have to post so new comers will know
> > he is a whack job and not listen to him. lol
> > Better he posts his whack and no one replies... that is a HUGE flag.
>
> The nearest we got to this was his disgraceful post about Peter Knaggs
> which was mostly ignored and, to keep it live, Hugh was reduced to
> replying to himself several times.
>
> --
> Gerry
Peter Knaggs disgraced the Forth community by going to EuroForth-2018
and claiming to be the world's expert on Forth linked-lists, and
solely qualified to set the Standard for the entire Forth community.
Peter Knaggs wants Forth programmers such as myself to get on our knees
and tell him that he is their leading expert who sets the Standard for them.
He was unable to get his code debugged, so he went without any code.
His design was a muddled mess containing multiple novice-level
blunders. If he were a high-school student, he would get a 'D' for this.
Peter Knaggs should resign from the Forth-200x committee because
he is too incompetent to implement a linked-list,
which is really high-school level programming.
Gerry Jackson is a sycophant of the Forth-200x committee.
This is why he gives Peter Knaggs 100% support for his EuroForth-2018
presentation, which I assume will be in Forth-200x soon (it may have
already gone through the CfV and been written in stone in Forth-200x).
Ed
May 17, 2019, 10:40:54 PM5/17/19
to
On Monday, 6 May 2019 14:39:56 UTC+10, hughag...@gmail.com wrote:
> ...
> ...
> I think that DXForth is somewhat over-impressed by his own creativity.
> He expects his customized linked-list to be super-duper compared to mine.
> This isn't true.
That would be Forth's gods mistaking rejection for competition.
> He expects his customized linked-list to be super-duper compared to mine.
> This isn't true.
hughag...@gmail.com
May 18, 2019, 6:05:23 PM5/18/19
to
On Friday, May 17, 2019 at 2:39:07 AM UTC-7, Gerry Jackson wrote:
> On 16/05/2019 22:46, Rick C wrote:
> >
>
> I see that he replied to my post on his Peter Knaggs discussion, that
> counts as another self reply to keep the thread live. I don't know
> whether he is a loon or just like a child, being naughty to draw
> attention to himself - naughty in his case means disgraceful ad hominem
> attacks and telling lies about people.
>
> Actually his post attacking me is a prime example of how he makes
> unwarranted assumptions, twists things and makes things up.
>
> --
> Gerry
I think that Peter Knaggs chose linked-lists as his subject of expertise
in an effort to offend me personally.
When I was on the Forth-200x mailing list, Elizabeth Rather said this
about my LIST.4TH code:
-------------------------------------------------------------------------
Does "*every* application" you write use exactly the same kind of data
arranged in the same way? If so, having written it once you can
reuse it often. If not, you either have to rearrange your data
to make it work or modify your "general-purpose" structure.
-------------------------------------------------------------------------
I strongly complained that this was not true.
I said that either Elizabeth Rather or myself should be kicked off
the Forth-200x mailing-list for gross incompetence.
Peter Knaggs kicked me off.
Now, ten years later, he decides to declare himself to be the world's
expert in Forth general-purpose data-structures, and he chooses
the linked-list for his demonstration.
I think that he is trying to offend me by doing this.
His expectation was that all of the Forth-200x mailing-list enthusiasts
would cheer for him, and say that he alone has figured out how to
implement a linked-list --- and say that my implementation was total crap.
This expectation didn't work out very well for Peter Knaggs.
He failed to write any working Forth code, and his design was a
muddled mess containing novice-level blunders, so it would never
work even if he did eventually write code for it.
So far, the only strong support that Peter Knaggs has gotten
came from Gerry Jackson (loyal as a beagle) who relentlessly
supports the Forth-200x committee no matter what depths
of incompetence they may descend to
Why did Peter Knaggs fail so badly at designing a linked-list package?
He does have a PhD., so you would think that he could succeed at this.
There are three possible explanations for his failure:
1.) Peter Knaggs is dumber than a fresh cow-patty on the summit of
Mount Everest. He couldn't figure out how to implement a linked list.
2.) Elizabeth Rather told him to design a linked-list package, but
purposely cripple it. Her goal was that it would be accepted, but then
nobody would use it because it doesn't work. Then she would say:
purposely cripple it. His goal was that it would be accepted, but then
nobody would use it because it doesn't work. Then he would say:
"If you want a linked-list package that is actually usable,
you have to buy VFX and get our proprietary package that includes
such super-duper features as FIND-NODE etc.."
Gerry Jackson is the only Forth-200x sycophant who is publicly
supporting Peter Jackson, so he will have to answer the question of
why Peter Knaggs failed to design a viable linked-list package.
So far, the silence from the Forth-200x enthusiasts has been deafening.
They are all embarrassed by Peter Knaggs' failure. They have decided
to take a low-profile and not publicly link themselves to Peter Knaggs.
Peter Knaggs himself is keeping a low-profile...
> On 16/05/2019 22:46, Rick C wrote:
> > On Thursday, May 16, 2019 at 3:59:20 PM UTC-4, Gerry Jackson wrote:
> >> On 16/05/2019 12:44, Rick C wrote:
> >>> Sometimes I wish people would just stop replying to him. Just like most trolls, if no one replies to him he will stop posting. But sooner or later there is someone who engages with him because he is just so outrageous and that is enough to keep him coming back. Many times people say they have to post so new comers will know he is a whack job and not listen to him. lol Better he posts his whack and no one replies... that is a HUGE flag.
> >>
> >> The nearest we got to this was his disgraceful post about Peter Knaggs
> >> which was mostly ignored and, to keep it live, Hugh was reduced to
> >> replying to himself several times.
> >
> > Yep, worked pretty well, eh? Not only does ignoring him reduce the unpleasant traffic, but the many self replies clearly label him as a loon.
> >> On 16/05/2019 12:44, Rick C wrote:
> >>> Sometimes I wish people would just stop replying to him. Just like most trolls, if no one replies to him he will stop posting. But sooner or later there is someone who engages with him because he is just so outrageous and that is enough to keep him coming back. Many times people say they have to post so new comers will know he is a whack job and not listen to him. lol Better he posts his whack and no one replies... that is a HUGE flag.
> >>
> >> The nearest we got to this was his disgraceful post about Peter Knaggs
> >> which was mostly ignored and, to keep it live, Hugh was reduced to
> >> replying to himself several times.
> >
> >
>
> I see that he replied to my post on his Peter Knaggs discussion, that
> counts as another self reply to keep the thread live. I don't know
> whether he is a loon or just like a child, being naughty to draw
> attention to himself - naughty in his case means disgraceful ad hominem
> attacks and telling lies about people.
>
> Actually his post attacking me is a prime example of how he makes
> unwarranted assumptions, twists things and makes things up.
>
> --
> Gerry
I think that Peter Knaggs chose linked-lists as his subject of expertise
in an effort to offend me personally.
When I was on the Forth-200x mailing list, Elizabeth Rather said this
about my LIST.4TH code:
-------------------------------------------------------------------------
Does "*every* application" you write use exactly the same kind of data
arranged in the same way? If so, having written it once you can
reuse it often. If not, you either have to rearrange your data
to make it work or modify your "general-purpose" structure.
-------------------------------------------------------------------------
I strongly complained that this was not true.
I said that either Elizabeth Rather or myself should be kicked off
the Forth-200x mailing-list for gross incompetence.
Peter Knaggs kicked me off.
Now, ten years later, he decides to declare himself to be the world's
expert in Forth general-purpose data-structures, and he chooses
the linked-list for his demonstration.
I think that he is trying to offend me by doing this.
His expectation was that all of the Forth-200x mailing-list enthusiasts
would cheer for him, and say that he alone has figured out how to
implement a linked-list --- and say that my implementation was total crap.
This expectation didn't work out very well for Peter Knaggs.
He failed to write any working Forth code, and his design was a
muddled mess containing novice-level blunders, so it would never
work even if he did eventually write code for it.
So far, the only strong support that Peter Knaggs has gotten
came from Gerry Jackson (loyal as a beagle) who relentlessly
supports the Forth-200x committee no matter what depths
of incompetence they may descend to
Why did Peter Knaggs fail so badly at designing a linked-list package?
He does have a PhD., so you would think that he could succeed at this.
There are three possible explanations for his failure:
1.) Peter Knaggs is dumber than a fresh cow-patty on the summit of
Mount Everest. He couldn't figure out how to implement a linked list.
2.) Elizabeth Rather told him to design a linked-list package, but
purposely cripple it. Her goal was that it would be accepted, but then
nobody would use it because it doesn't work. Then she would say:
"...in Forth it's so easy to build data structures that are exactly right
for the particular application at hand that worrying about what pre-built
structures you have and how to use them is just not worth the bother."
3.) Stephen Pelc told him to design a linked-list package, but
for the particular application at hand that worrying about what pre-built
structures you have and how to use them is just not worth the bother."
purposely cripple it. His goal was that it would be accepted, but then
nobody would use it because it doesn't work. Then he would say:
"If you want a linked-list package that is actually usable,
you have to buy VFX and get our proprietary package that includes
such super-duper features as FIND-NODE etc.."
Gerry Jackson is the only Forth-200x sycophant who is publicly
supporting Peter Jackson, so he will have to answer the question of
why Peter Knaggs failed to design a viable linked-list package.
So far, the silence from the Forth-200x enthusiasts has been deafening.
They are all embarrassed by Peter Knaggs' failure. They have decided
to take a low-profile and not publicly link themselves to Peter Knaggs.
Peter Knaggs himself is keeping a low-profile...
hughag...@gmail.com
May 24, 2019, 10:17:12 PM5/24/19
to
> >> On 16/05/2019 12:44, Rick C wrote:
> >>> Sometimes I wish people would just stop replying to him. Just like most trolls, if no one replies to him he will stop posting. But sooner or later there is someone who engages with him because he is just so outrageous and that is enough to keep him coming back. Many times people say they have to post so new comers will know he is a whack job and not listen to him. lol Better he posts his whack and no one replies... that is a HUGE flag.
> >>
> >> The nearest we got to this was his disgraceful post about Peter Knaggs
> >> which was mostly ignored and, to keep it live, Hugh was reduced to
> >> replying to himself several times.
> >
> > Yep, worked pretty well, eh? Not only does ignoring him reduce the unpleasant traffic, but the many self replies clearly label him as a loon.
>
> He's self-replied again (that's the 9th time in that thread) getting
> >>> Sometimes I wish people would just stop replying to him. Just like most trolls, if no one replies to him he will stop posting. But sooner or later there is someone who engages with him because he is just so outrageous and that is enough to keep him coming back. Many times people say they have to post so new comers will know he is a whack job and not listen to him. lol Better he posts his whack and no one replies... that is a HUGE flag.
> >>
> >> The nearest we got to this was his disgraceful post about Peter Knaggs
> >> which was mostly ignored and, to keep it live, Hugh was reduced to
> >> replying to himself several times.
> >
> > Yep, worked pretty well, eh? Not only does ignoring him reduce the unpleasant traffic, but the many self replies clearly label him as a loon.
>
> even more outrageous in his lies and interpreting silence as
> embarrassment and support for Peter Knaggs, rather than accepting the
> simpler explanation that he's being ignored.
>
> Perhaps the "Seven deadly sins of narcissism" on Wikipedia
> (https://en.wikipedia.org/wiki/Narcissism) applies.
>
> --
> Gerry
I'm not lying.
My LIST.4TH works, and it is designed in a way that makes sense.
Peter Knaggs doesn't have a working implementation, and his design
is a muddled mess containing multiple novice-level blunders.
That is the truth!
Of course, I had to read the Wikipedia article to find out what the
Seven Deadly Sins of Narcissism are.
1.) Shamelessness --- This is definitely the Forth-200x committee.
They fail badly at even the simplest Forth programming,
such as implementing linked-lists, but they aren't ashamed of this.
2.) Magical Thinking --- This is definitely the Forth-200x committee.
They believe that software design will work without being tested.
Elizabeth Rather didn't bother with a reference compiler for ANS-Forth.
Peter Knaggs and Andrew Haley both went to EuroForth without
source-code, filled with faith that their designs would certainly work.
3.) Arrogance --- This is definitely the Forth-200x committee.
They believe that they command the whole Forth community,
and all Forthers must kneel before them.
4.) Envy --- This is definitely the Forth-200x committee.
Wikipedia says:
"A narcissist may secure a sense of superiority in the face of
another person's ability by using contempt
to minimize the other person or their achievements."
This is what they have been doing for years, saying that my SORT
doesn't work (Alex McDonald), saying that my STRING-STACK.4TH
is crap (Gerry Jackson), saying that my rquotations don't work
(Anton Ertl and Bernd Paysan), etc..
5.) Entitlement --- This is definitely the Forth-200x committee.
Wikipedia says:
"Narcissists hold unreasonable expectations of particularly favorable
treatment and automatic compliance because they consider themselves special.
Failure to comply is considered an attack on their superiority,
and the perpetrator is considered an "awkward" or "difficult" person."
This is pretty much the same as #3 above. They believe that they are
entitled to rule over mere Forth programmers such as myself,
and that anybody who refuses to kneel is being awkward and difficult.
6.) Exploitation --- This is definitely the Forth-200x committee.
They lure people onto the Forth-200x mailing list, then list that
person's name as a contributor to Forth-200x, implying that the
person supports Forth-200x, after the person has turned against
Forth-200x. ANS-Forth was the same, for example by listing
Charles Moore in the ANS-Forth document as a contributor/supporter,
despite the fact that he turned against them in 1987.
7.) Bad Boundaries --- This is definitely the Forth-200x committee.
Wikipedia says:
"Narcissists do not recognize that they have boundaries
and that others are separate and are not extensions of themselves.
Others either exist to meet their needs or may as well not exist at all."
The committee claim to set the Standard for all Forth programmers, without
obtaining permission from most of them (definitely not from those
who have turned against Forth-200x). They say that any Forth programmer
who doesn't support them is not a Forth programmer at all
(hasn't had the "aha!" moment, in Andrew Haley's terminology).
None of this applies to me.
I just write Forth code that works.
hughag...@gmail.com
Aug 16, 2019, 10:42:02 PM8/16/19
to
On Sunday, May 5, 2019 at 6:35:40 AM UTC-7, foxaudio...@gmail.com wrote:
"magnitude of the effort" that they put into the Standard design:
On Thursday, August 15, 2019 at 4:41:55 PM UTC-7, Krishna Myneni wrote:
> I appreciate the effort that the unofficial standards committee puts into
> it and, in any group effort such as this, there will be politics.
> Consensus may not always produce the best result but it is likely to
> improve the product more often than not. The Forth-2012 document, which
> borrows considerably from the ANS Forth documentation, clearly took a lot
> of effort and deliberation. Legitimate concerns about a revision to the
> unofficial standard should be evaluated fairly. However, people who only
> provide constant negative feedback clearly don't understand the magnitude
> of the effort.
So, what is the status of Peter Knaggs non-working linked-list design?
Has it been written in stone as part of the Forth-200x Standard yet?
hughag...@gmail.com
Dec 11, 2019, 10:40:19 PM12/11/19
to
On Sunday, May 5, 2019 at 7:17:39 PM UTC-7, hughag...@gmail.com wrote:
> [Peter Knaggs] says this:
https://groups.google.com/forum/#!topic/comp.lang.forth/S6GsWXapUAs%5B1-25%5D
Doug Hoffman and other ANS-Forth cult members predictably hijacked
the thread with a stream of drivel about off-topic such as
screen files versus sequential files, LaTeX versus MS Word, etc..
Now we have this gem:
On Wednesday, December 11, 2019 at 7:20:41 AM UTC-7, Doug Hoffman wrote:
> On 12/10/19 11:10 PM, hughag...@gmail.com wrote:
>
> > You don't know the difference between a linked-list and an array.
>
> I suggest you not get locked in to your personal definitions.
>
> https://en.wikipedia.org/wiki/List_(abstract_data_type)
>
> "Some languages may allow list types to be indexed or sliced like array
> types, in which case the data type is more accurately described as an
> array. ... List data types are often implemented using array data
> structures or linked lists of some sort, but other data structures may
> be more appropriate for some applications."
Notice the similarity between Doug Hoffman's quote and Peter Knaggs' quote?
They both believe that arrays are the same as linked lists! LOL
Peter Knaggs is a member of the Forth-200x committee, and Doug Hoffman
has the same level of incompetence, so it would only be fair that
Doug Hoffman should get appointed to the Forth-200x committee too!
I suggest that the Forth-200x committee not get locked in to
learning about computer science by reading Wikipedia.
> [Peter Knaggs] says this:
> --------------------------------------------------------------
> The words have been defined in a way that does not require any particular implementation, thus allowing the developer to use the most appropriate implementation method for there system. For example:
> Array ...
> Linked List ...
> Array List ...
> Bucket List ...
> --------------------------------------------------------------
> This is more B.S.. He seems to believe that he has a mandate to
> define behavior rather than implementation, but his solution is
> impractical. He should just figure out how to implement a linked-list.
> A linked-list could be *simulated* with an
> array, but this is not a linked-list. Performance will be abysmal!
Recently I started a thread on developing a viable Forth standard.
> The words have been defined in a way that does not require any particular implementation, thus allowing the developer to use the most appropriate implementation method for there system. For example:
> Array ...
> Linked List ...
> Array List ...
> Bucket List ...
> --------------------------------------------------------------
> This is more B.S.. He seems to believe that he has a mandate to
> define behavior rather than implementation, but his solution is
> impractical. He should just figure out how to implement a linked-list.
> A linked-list could be *simulated* with an
> array, but this is not a linked-list. Performance will be abysmal!
https://groups.google.com/forum/#!topic/comp.lang.forth/S6GsWXapUAs%5B1-25%5D
Doug Hoffman and other ANS-Forth cult members predictably hijacked
the thread with a stream of drivel about off-topic such as
screen files versus sequential files, LaTeX versus MS Word, etc..
Now we have this gem:
On Wednesday, December 11, 2019 at 7:20:41 AM UTC-7, Doug Hoffman wrote:
> On 12/10/19 11:10 PM, hughag...@gmail.com wrote:
>
> > You don't know the difference between a linked-list and an array.
>
> I suggest you not get locked in to your personal definitions.
>
> https://en.wikipedia.org/wiki/List_(abstract_data_type)
>
> "Some languages may allow list types to be indexed or sliced like array
> types, in which case the data type is more accurately described as an
> array. ... List data types are often implemented using array data
> structures or linked lists of some sort, but other data structures may
> be more appropriate for some applications."
Notice the similarity between Doug Hoffman's quote and Peter Knaggs' quote?
They both believe that arrays are the same as linked lists! LOL
Peter Knaggs is a member of the Forth-200x committee, and Doug Hoffman
has the same level of incompetence, so it would only be fair that
Doug Hoffman should get appointed to the Forth-200x committee too!
I suggest that the Forth-200x committee not get locked in to
learning about computer science by reading Wikipedia.
0 new messages