dxf <dxforth@gmail.com> writes:
>On 10/09/2023 1:29 am, Anton Ertl wrote:
>> Still we use terms with common meaning, not with Humpty Dumpty's
>> meaning. E.g., we look at Wikepdia what they mean.
>
>Wikipedia is more than common meaning. It has set itself up as authority.

Has it? Die Wikipedia send out troops that conquered the world and
demanded that everyone accepts it as authority?

My view is that Wikipedia is as authoritative as we accept. And I
personally find that it usually does quite well at definitions. In
the case of
<https://en.wikipedia.org/wiki/Object-oriented_programming> I don't
find that the first paragraph is a good definition of OOP (whereas for
other subjects the first sentence or first paragraph often is). It's
not wrong, but it fails to include essential parts.

>The OOP page includes Leo Brodie's criticism from 'Thinking FORTH' (another
>authority apparently). This was too much for one reader (see Talk page)
>who took the view only criticism from 'recognized' authorities be used - if
>at all.

This writer does not mention Brodie or anybody else, and it's unclear
what he means.

Concerning Brodie's criticism, he writes in the preface to the 1994
edition:

|Of all the opinions in the book, the one that I most regret seeing in
|print is my criticism of object-oriented programming. Since penning
|this book, I’ve had the pleasure of writing an application in a
|version of Forth with support for object-oriented programming,
|developed by Digalog Corp. of Ventura, California. I’m no expert, but
|it’s clear that the methodology has much to offer.

Reading through the section in Thinking Forth called "No Segregation
Without Representation", he seems to have some specific program in
mind that claimed to use objects, and his criticism applies to that;
but given the lack of concreteness, I don't know what he actually
means. Some othe the things he criticises "objects" for are actually
things that OOP languages tends to make easy (e.g., the claimed lack
of extensibility).

He then goes on to criticise more concertely and rightly the IBM PC
BIOS interface, which leads to inefficiency in displaying text on the
screen. The inefficiency has led to programs that directly write to
the video memory, and to the success of 100% IBM PC compatible
computers and the demise of BIOS-compatible computers. But this has
little to do with OOP. It's just an inefficient interface.
Interestingly, these days no application program writes directly to
video memory, but they also don't use character-by-character or
pixel-by-pixel interfaces.

- anton
--
M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
New standard: https://forth-standard.org/
EuroForth 2023: https://euro.theforth.net/2023

On Saturday, September 9, 2023 at 9:24:12 PM UTC+2, Ron Braithwaite wrote:
> On Friday, September 8, 2023 at 11:45:07 AM UTC-7, Howerd wrote:
> > On Thursday, September 7, 2023 at 9:48:30 AM UTC+2, Anton Ertl wrote:
> > > minforth <minf...@arcor.de> writes:
> > > >Dick Pountain once wrote a whole book about object-oriented Forth
> > > >by stacking several CREATE DOES (BUILDS) structures over
> > > >each other. I found it rather intriguing at that time, although
> > > >many OO purists rejected it.
> > > Not sure what an OO purist is.
> > >
> > > Anyway, I have read the book, and found it interesting at the time.
> > > But the more I learned about object-oriented programming, the more I
> > > found that Pountain mostly missed the point. The essential part of
> > > OOP is run-time polymorphism (dynamic binding). Most of the book does
> > > not deal with this feature at all; IIRC only the last chapter even
> > > concerns itself with this topic, and it does so in a clumsy and
> > > inefficient way. So this book has rightly been ignored by everyone
> > > who really implemented and used OOP in Forth.
> > >
> > > If you want to see how a minimalistic OOP package in Forth can look
> > > like, look at <https://bernd-paysan.de/mini-oof.html>.
> > >
> > > - anton
> > > --
> > > M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
> > > comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
> > > New standard: https://forth-standard.org/
> > > EuroForth 2023: https://euro.theforth.net/2023
> > Hi Anton,
> > You say "The essential part of OOP is run-time polymorphism", and I think you are right, in that what many ideas like OOP are trying to do is to get back some dynamic functionality, after it has been nailed down as static by one or other of the batch processing languages.
> > I find it interesting that the Udemy course that I just took (mainly so I could speak to my colleagues in the language they were using) does not mention run-time polymorphism, nor any sort of binding, run-time, compile time etc.
> > This confirms my theory that "Object Oriented Programming" is a marketing concept that can mean whatever you want it to mean ;-)
> >
> > Cheers,
> > Howerd
> I agree with the statement "The essential part of OOP is run-time polymorphism". I think there is definitely a use case in Forth for run-time polymorphism, but I also think it is kind of rare.
>
> Years ago, the Whitewater Group developed a really cool proprietary language called Actor (along with some other great stuff) that had lots of great ideas that basically evolved Smalltalk up to the next level. One of those ideas was selectively being able to label functions as Static or Dynamic, which allowed the compiler to optimize. Unfortunately, the Whitewater Group was purchased by Borland for their Windows abstraction layer and they killed Actor.
>
> I dropped out of the initial ANSI efforts in 1990 in order to go teach at the University of Zimbabwe, where one of the courses I taught was Object Oriented Programming with Actor. The Whitewater Group was kind enough to provide me with all sorts of materials and free licenses for students. It was really well received and when Borland dropped it, I contacted the Product Manager. She told me that Borland had decided to focus on C++ and had dropped Actor because it competed with it. Really sad.
>
> So, back to Forth, I am all in favor of having Object Oriented extensions that I could plug into a “standard” Forth without having to rewrite them from scratch.
>
> Back to lurk mode,
> Ron Braithwaite
Hi Ron,

It is a always a shame when fashion trends or marketing decisions force good ideas into the shadows.
" I am all in favor of having Object Oriented extensions that I could plug into a “standard” Forth " - there are a few of those around....
But what style of OO would your ideal extension be?

Cheers,
Howerd

https://cosy.com/ simply implements dynamic lists-of-lists evolved from Arthur Whitney's K simplified from APL .
The header for a list is , as a CoSy word list , `( Type Count refCount )` .. Objects are freed when ` refCount returns to 0 .
Anything can be modeled , aka : implemented in such structures and inherits the total APL level vocabulary acting on lists .
` Dictionaries are 2 item lists of `( names values )` . Databases are generally dictionaries where the ` values are correlated lists of item values .
For instance a general form of a ledger has a 0th item the column labels `( TimeStamp Description From To Amount Notes )` . The ` 1th item is then the 6 columns of values . ' flip will convert them to a list of individual ` records . I demoed this at the last SV-FIG Zoom : https://www.cosy.com/CoSy/y23/SV-FIG_20230826_commentary.html .

So far as I see ` objects are just lists of the form `( data attribueDictionary )` . Arthur actually implemented K's dictionaries as `( names values attributes )` , but I found that better left to cases where needed . In fact I originally thought of making ` dictionary a Type , but have never found that complication to not simply be more , well , complication . I had a 4th ` meta cell in headers but found I never used it , certainly not enough to justify an extra cell in all headers .

That's my take on ` objects . They are just data with attached attribute dictionaries .
Long ago I had a discussion w Alan Kay saying that what the notion of ` objects missed was the ` geometric value of APL's arrays ( simplified to lists-of-lists ) .

albert@cherry.(none) (albert) writes:
>But what to think of my specification of my QSORT
>
> 8 \ Sort the range FIRST to LAST (inclusive) of item compared
> 9 \ by the xt COMPARING and exchanged by the xt EXHANGING.
> 10 \ The xt's are filled in into *< and *<--> and must observe the
> 11 \ interface. All indices be compatible with these xt's.
> 12 \ After the call we have that :
> 13 \ ``For FIRST<=I<J<=LAST I J *< EXECUTE leaves TRUE.''
>
>This restricts the items to be sorted in no way.
>If this count as polymorphism, I don't think is rare.

If you look at
<https://en.wikipedia.org/wiki/Polymorphism_(computer_science)>, you
will find that this is listed as parametric polymorphism (aka
genericity). For statically typed languages it was quite a struggle
to reconcile parametric polymorphism with subtype polymorphism while
avoiding run-time type errors (as messages, or worse, as undefined
behaviour). Java became quite a bit more complex with the addition of
genericity.

- anton
--
M. Anton Ertl http://www.complang.tuwien.ac.at/anton/home.html
comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
New standard: https://forth-standard.org/
EuroForth 2023: https://euro.theforth.net/2023