From Newsgroup: comp.lang.ada

On LinkedIn Richard Riehle suggested that strong typing was claimed by many
languages but Ada offers more in precision typing. I wonder if precision
would fit around the coin?
--
Regards, Kc
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On 2025-08-18 12:29, Kevin Chadwick wrote:

On LinkedIn Richard Riehle suggested that strong typing was claimed by many languages but Ada offers more in precision typing. I wonder if precision would fit around the coin?

These are unrelated issues. Strong typing is about:

1. Any object has a type. Note that many OO languages violate this
principle, but not Ada which has T'Class and T separate.

2. Types have definite set of operations, arguments and results are
typed. No, ellipsis, no messages (calling an operation on any object),
no pattern matching of calls etc.

3. Types are insulated unless a relationship is explicitly stated by the programmer. E.g. no implicit type conversions.

What Richard refers to is an accuracy of mapping a type to the problem
space. Talking about numerical entities the model types have precision,
range, accuracy (float vs. fixed-point vs. unbounded), behavior like
rounding, handling of exceptional states (breaking out the model) etc.

A counter example to Richard's statement. A weakly typed PL/1 had
precision types.
--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Mon, 18 Aug 2025, Dmitry A. Kazakov wrote: |-----------------------------------------------------------------------------| |"These are unrelated issues. Strong typing is about: | | | |1. Any object has a type. Note that many OO languages violate this principle,| |but not Ada which has T'Class and T separate. | | | |[. . .]" | |-----------------------------------------------------------------------------|

Dear Mister Kazakov,

Ada is a strongly typed language so Ada is not an OOP language.

With best regards.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On 2025-08-18 15:59, Niocláisín Cóilín de Ghlostéir wrote:

On Mon, 18 Aug 2025, Dmitry A. Kazakov wrote: |-----------------------------------------------------------------------------|
|"These are unrelated issues. Strong typing is about: |
| |
|1. Any object has a type. Note that many OO languages violate this principle,|
|but not Ada which has T'Class and T separate. |
| |
|[. . .]" |
|-----------------------------------------------------------------------------|

Ada is a strongly typed language so Ada is not an OOP language.

Ada is a strongly typed OO language.
--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

This message is in MIME format. The first part should be readable text,
while the remaining parts are likely unreadable without MIME-aware tools.

--708268602-1793013771-1755557527=:2770018
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: QUOTED-PRINTABLE

On Mon, 18 Aug 2025, Dmitry A. Kazakov wrote: |--------------------------------------|
|"Ada is a strongly typed OO language."| |--------------------------------------|

Dear Mister Kazakov:

I am curious as to how such an elite expert computer scientist as yourself=
=20
concluded so perversely. Professor Alan Curtis Kay professes: =E2=80=9CI=E2= =80=99ve been=20
shown some very, very strange-looking pieces of code over the years by=20 various people, including people in universities, that they have said is=20
OOP code, and written in an OOP language=E2=80=94and actually, I made up th=
e term=20
object-oriented=E2=80=9D. Cf.
Kay, A. C. (1997). The Computer Revolution Hasn=E2=80=99t Happened Yet. In = The=20
12th ACM SIGPLAN Conference on Object-Oriented Programming, Systems,=20 Languages, and Applications. HTTP://files.Squeak.org/Media/AlanKay/Alan\%20Kay\%20at\%20OOPSLA\%201997\%= 20-\%20The\%20computer\%20revolution\%20hasnt\%20happened\%20yet.ogg HTTP://blog.Moryton.net/2007/12/computer-revolution-hasnt-happened-yet.html HTTP://Gloucester.Insomnia247.NL/Alan_Curtis_Kay/Kay_1997__I_made_up_the_te= rm_object-oriented,_and_I_can_tell_you_I_did_not_have_C++_in_mind.avi

Professor Alan Curtis Kay says that Ada (while calling Ada =E2=80=9CADA=E2= =80=9D (sic)) is=20
not an OOP language but one of the =E2=80=9CBetter Old Things=E2=80=9D abou=
t =E2=80=9CAbstract=20
Data Types which was really staying with an assignment-centered way of=20 thinking about programming=E2=80=9D.

Contrast
ADA_is_a_good_non-OOP_language_says_Alan_Curtis_Kay.JPG
with
HTTP://Gloucester.Insomnia247.NL/Alan_Curtis_Kay/New_Things_OOP.JPG

Cf.
=E2=80=9COh, yeah, I had to sigh when Alan Kay, the keynote speaker, had a = slide
with Ada spelled as "ADA".=E2=80=9D says Gary Kephart, =E2=80=9COOPSLA [was=
Re: Tri-Ada=20
Soars; Hal eats crow -Reply]=E2=80=9D, Team-Ada, Wed, 8 Oct 1997 14:16:31 -= 0700 HTTPS://LISTSERV.ACM.org/SCRIPTS/WA-ACMLPX.CGI?A2=3Dind9710&L=3DTEAM-ADA&P= =3DR1772

Cf. HTTP://Gloucester.Insomnia247.NL/Alan_Curtis_Kay/ADA_is_a_good_non-OOP_lang= uage_says_Alan_Curtis_Kay.JPG
Cf.
=E2=80=9CDate: Wed, 23 Jul 2003 09:33:31 -0800

To: Stefan Ram [removed for privacy]

From=20Alan Kay [removed for privacy]

Subject: Re: Clarification of "object-oriented"
[. . .]
The second phase of this was to finally understand LISP and then=20

using this understanding to make much nicer and smaller and more=20

powerful and more late bound understructures. [. . .]
[. . .]

[. . .]

(I'm not against types, but I don't know of any type systems that=20

aren't a complete pain, so I still like dynamic typing.)


OOP to me means only messaging, local retention and protection and=20

hiding of state-process, and extreme late-binding of all things. It=20

can be done in Smalltalk and in LISP. There are possibly other=20

systems in which this is possible, but I'm not aware of them.=E2=80=9D
says
HTTPS://userPage.FU-Berlin.De/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_de

Precisely not Ada!

Can you cite an authoritative prescriptive definition for =E2=80=9COO langu= age=E2=80=9D=20
which compels Professor Kay to confess that he must conclude that he=20
himself defined that Ada is an =E2=80=9COO language=E2=80=9D despite Ada ha= ving =E2=80=9Cany type=20
system=E2=80=9D and potentially not demanding messaging and allowing global= =20
variables and demanding compilation-time checking? I note that you say =E2= =80=9COO=20
language=E2=80=9D about a programming language (Ada), but Professor Kay say=
s =E2=80=9COOP=20
language=E2=80=9D and Kay says that Ada is not an OOP language. So, do you=
=20
theorize that Ada (i.e. a programming language) can be an =E2=80=9COO langu= age=E2=80=9D=20
without being an =E2=80=9COOP language=E2=80=9D? This really does not convi= nce me! Sorry!

I mean no disrespect against you.

Sincerely.
--708268602-1793013771-1755557527=:2770018--
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Mon, 18 Aug 2025 13:08:32 +0200, Dmitry A. Kazakov wrote:

What Richard refers to is an accuracy of mapping a type to the problem
space. Talking about numerical entities the model types have precision, range, accuracy (float vs. fixed-point vs. unbounded), behavior like rounding, handling of exceptional states (breaking out the model) etc.

Subclassing?
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On 19/08/2025 00:27, Lawrence DOliveiro wrote:

On Mon, 18 Aug 2025 13:08:32 +0200, Dmitry A. Kazakov wrote:

What Richard refers to is an accuracy of mapping a type to the problem
space. Talking about numerical entities the model types have precision,
range, accuracy (float vs. fixed-point vs. unbounded), behavior like
rounding, handling of exceptional states (breaking out the model) etc.

Subclassing?

For example engineering parameters so only valid inputs are possible using
e.g. ranges. That could be a subtype or new type etc..
--
Regards, Kc
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

Le 18/08/2025 à 17:03, Dmitry A. Kazakov a écrit :

Ada is a strongly typed language so Ada is not an OOP language.

Ada is a strongly typed OO language.

More precisely:
OOP implies a weakening of the typing system, since a wider class can
contain any object of the subclass.
But in Ada, this can happen only for objects of a class-wide type; so
you get it only if you ask for it, and you immediately know from the
type of an object which values it can hold.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On 2025-08-19 08:24, J-P. Rosen wrote:

Le 18/08/2025 à 17:03, Dmitry A. Kazakov a écrit :

Ada is a strongly typed language so Ada is not an OOP language.

Ada is a strongly typed OO language.

More precisely:
OOP implies a weakening of the typing system, since a wider class can contain any object of the subclass.
But in Ada, this can happen only for objects of a class-wide type; so
you get it only if you ask for it, and you immediately know from the
type of an object which values it can hold.

Yes, however class-wide objects only behave as if they held specific
type objects. The class-wide type is still a different type, so the type system remains strong.

Constrained subtypes are even "weaker" in that respect, e.g. Positive
vs. Integer.
--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Tue, 19 Aug 2025 08:24:23 +0200, J-P. Rosen wrote:

OOP implies a weakening of the typing system, since a wider class can
contain any object of the subclass.

Or conversely, a strengthening, since operations defined only on a
subclass will not work on the superclass.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Tue, 19 Aug 2025 09:29:25 +0200, Dmitry A. Kazakov wrote:

Constrained subtypes are even "weaker" in that respect, e.g. Positive
vs. Integer.

Subtype restrictions can overlap. In OOP I suppose you would get an
analogous effect via multiple inheritance.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Wed, 20 Aug 2025, so became written: |-----------------------------------------------------------------------|
|"On Tue, 19 Aug 2025 08:24:23 +0200, J-P. Rosen wrote: |
| |

OOP implies a weakening of the typing system, since a wider class can| contain any object of the subclass. |

| |
|Or conversely, a strengthening, since operations defined only on a | |subclass will not work on the superclass." | |-----------------------------------------------------------------------|

Operations defined only on a subclass would result in a superclass (or any unrelated class) receivng a message which does not match its protocol so
it would crash. That is OOP. We do not need that. That is not Ada. We need Ada.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On 2025-08-20 15:59, Niocláisín Cóilín de Ghlostéir wrote:

On Wed, 20 Aug 2025, so became written: |-----------------------------------------------------------------------| |"On Tue, 19 Aug 2025 08:24:23 +0200, J-P. Rosen wrote:                 |
|                                                                       |

OOP implies a weakening of the typing system, since a wider class can| contain any object of the subclass.                                  |

|                                                                       |
|Or conversely, a strengthening, since operations defined only on a     | |subclass will not work on the superclass."                             |
|-----------------------------------------------------------------------|

Operations defined only on a subclass would result in a superclass (or
any unrelated class) receivng a message which does not match its
protocol so it would crash. That is OOP. We do not need that. That is
not Ada. We need Ada.

Class is a set of types. Subclass is a subset of types.

In Ada's OO a subclass is a set of types derived from some type:

S <: T

Then S'Class is a subclass of T'Class. E.g.

type T is tagged ...;
type S is new T with ...; -- S'Class is a subclass of T'Class

In no way an operation declared on S:

procedure F (X : in out S);

can be called on T. Ada is type safe.
--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

I get lost in OOP talk. So much...meh.

Constrained subtypes are even "weaker" in that respect, e.g. Positive
vs. Integer.

I don't understand this point as you can just use new types instead of
subtypes as needed.
--
Regards, Kc
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Wed, 20 Aug 2025, Dmitry A. Kazakov wrote: |-----------------------------------------------------------------|
|"Then S'Class is a subclass of T'Class. E.g. |
| |
| type T is tagged ...; |
| type S is new T with ...; -- S'Class is a subclass of T'Class|
| |
|In no way an operation declared on S: |
| |
| procedure F (X : in out S); |
| |
|can be called on T. Ada is type safe." | |-----------------------------------------------------------------|

So Ada is not an OOP language. Cf. Professor Alan Curtis Kay says:
"I don't know of any type systems that

aren't a complete pain, so I still like dynamic typing."
via
HTTPS://userPage.FU-Berlin.De/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_de

Cf. a Smalltalk superclass can receive a subclass message for which no superclass counterpart exists, so causing a crash. OOP is poop!
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On 2025-08-18 18:03, Dmitry A. Kazakov wrote:

On 2025-08-18 15:59, Niocláisín Cóilín de Ghlostéir wrote:

On Mon, 18 Aug 2025, Dmitry A. Kazakov wrote:
|-----------------------------------------------------------------------------|
|"These are unrelated issues. Strong typing is
about:                         |
|                                                                             |
|1. Any object has a type. Note that many OO languages violate this
principle,|
|but not Ada which has T'Class and T
separate.                                |
|                                                                             |
|[. .
.]"                                                                     |
|-----------------------------------------------------------------------------|

Ada is a strongly typed language so Ada is not an OOP language.

Ada is a strongly typed OO language.

I would say: Ada supports object-oriented programming, but also supports
other programming paradigms. So calling Ada an "OO language" is saying
too little.

Some people called Ada 83 an "object-based" language, perhaps because
Ada programs typically modelled the real application objects (as
abstract data types) even before tagged types were available.

It seems to me that the strength of typing in a language is mostly
orthogonal to the differences between object-oriented programming and
other paradigms.

But I understand that some people may feel that the "freedom" of weak or
duck typing is important to their personal programming style, and
perhaps especially so for object-oriented programming where it has a
long history, as shown by other posts in this thread.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

Some people called Ada 83 an "object-based" language, perhaps because
Ada programs typically modelled the real application objects (as
abstract data types) even before tagged types were available.

This guy researched the origins of OOP with a focus on C++ apparently
botching it up. I'm not sure how interesting anyone might find it to be.

"https://youtu.be/wo84LFzx5nI"
--
Regards, Kc
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On 2025-08-20 17:49, Kevin Chadwick wrote:

I get lost in OOP talk. So much...meh.

Constrained subtypes are even "weaker" in that respect, e.g. Positive
vs. Integer.

I don't understand this point as you can just use new types instead of subtypes as needed.

The point is about the types algebra. If you have any relations between
types => substitution, you necessarily weaken typing.

Of course you can have nothing of that, but then you loose generic
programming = programming in terms of sets of types (closed by some
relation.)
--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On 2025-08-20 19:18, Niocláisín Cóilín de Ghlostéir wrote:

So Ada is not an OOP language. Cf. Professor Alan Curtis Kay says:

To be clear, I don't care what Prof. Kay says.

Cf. a Smalltalk superclass can receive a subclass message for which no superclass counterpart exists, so causing a crash. OOP is poop!

I care even less about Smalltalk. It is about Ada. I explained that your suggestion about Ada subclasses evidently wrong.
--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Wed, 20 Aug 2025, Niklas Holsti wrote: |--------------------------------------------------------------------------| |"Some people called Ada 83 an "object-based" language, perhaps because Ada| |programs typically modelled the real application objects (as abstract data| |types) even before tagged types were available." | |--------------------------------------------------------------------------|

Dear Dr. Holsti,

Thanks for this contribution.

The person who coined "object-based" professes that OOP necessarily
involves inheritance, whereas "object-based" programming does not.
However, he did not coin "OOP".

Even \cite{Objective-C} professes that inheritence is not necessary for
OOP. (But then again, it is not by Alan Curtis Kay, and it professes that Objective C be an OOP language, so do not rely on it for what an "OOP" language is!)

"OOP to me means only messaging, local retention and protection and

hiding of state-process, and extreme late-binding of all things."
says
HTTPS://userPage.FU-Berlin.De/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_de
It might be possible to interpret this quotation to not necessitate inheritance, even with the part about "extreme late-binding of all
things."


@book{Objective-C,
author = {Cox, Brad J.},
title = {Object oriented programming: an evolutionary approach},
year = {1987},
note = {``Reprinted with corrections April, 1987
Copyright {\copyright} 1986 by Productivity Products International,
Inc.''},
publisher = {Addison-Wesley}
}
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

This message is in MIME format. The first part should be readable text,
while the remaining parts are likely unreadable without MIME-aware tools.

--708268602-236997958-1755722308=:435770
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: QUOTED-PRINTABLE

On Wed, 20 Aug 2025, Dmitry A. Kazakov wrote: |------------------------------------------------------------------------|
|"On 2025-08-20 19:18, Niocl=C3=A1is=C3=ADn C=C3=B3il=C3=ADn de Ghlost=C3= =A9ir wrote: |
| |

So Ada is not an OOP language. Cf. Professor Alan Curtis Kay says: |

| |
|To be clear, I don't care what Prof. Kay says." | |------------------------------------------------------------------------|

Please stop misusing a term which Prof. Kay coined. If you do not care=20
about what Prof. Kay says, then you do not care about object orientation.=
=20
It is fair enough for some person to not care about object orientation.=20 Instead, incorrectly boasting about being an OO expert who writes in an OO=
=20
language when this languague - Ada - is not an OO language is a bad idea,=
=20
so please stop so.

|-------------------------------------------------------------------------|
|"> Cf. a Smalltalk superclass can receive a subclass message for which no|

superclass counterpart exists, so causing a crash. OOP is poop! |

| |
|I care even less about Smalltalk. It is about Ada. I explained that your | |suggestion about Ada subclasses evidently wrong." | |-------------------------------------------------------------------------|

I made no "suggestion about Ada subclasses" in this thread, as I clearly=20 referred to an OOP language so clearly excluding Ada. Indeed, you actually=
=20
quote me saying: "So Ada is not an OOP language."! --708268602-236997958-1755722308=:435770--
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Wed, 20 Aug 2025 22:38:25 +0200, Niocláisín Cóilín de Ghlostéir wrote:

Please stop misusing a term which Prof. Kay coined.

Did he trademark the term? Or does he own the copyright on it? Did he even invent the concept?

No, no and no.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

The person who invented the word that is "square" did not trademark it;
did not copyright it; and did not invent the first square. Another thing
which he did not do is wanting persons to call circles "squares". If
persons want to talk about circles, then they must not call them
"squares".

Cf. HTTPS://WWW.JewishLearningMatters.com/Lesson2-The-Holocaust-The-Role-of-Propaganda-1778.aspx
(but I fail to find any plausible evidence that Goebbels ever really did
say any such thing about circles and squares).
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

Niocláisín Cóilín de Ghlostéir <Spamassassin@irrt.De> writes:

On Wed, 20 Aug 2025, Dmitry A. Kazakov wrote: |------------------------------------------------------------------------| |"On 2025-08-20 19:18, Niocláisín Cóilín de Ghlostéir wrote: |
| |

So Ada is not an OOP language. Cf. Professor Alan Curtis Kay says: |

| | |To be clear, I don't care what Prof. Kay says." | |------------------------------------------------------------------------|

Please stop misusing a term which Prof. Kay coined. If you do not care
about what Prof. Kay says, then you do not care about object orientation.

Nonsense. Alan Kay has his own definition of "OOP", but that
definition is not binding on the rest of us.

Smalltalk-style and Simula-style models can both reasonably be
called OOP.

If you happen not to like languages that claim to be OOP but don't
conform to Alan Kay's definition, that's fine, but I don't see
that there's a lot more to say about it. If you want to discuss
the benefits of one flavor of OOP over another, I suggest that
comp.lang.ada is not the best place for that discussion.

You don't think Ada is OOP. That's fine. You're entitled to
your opinion. But demanding that others must agree with you (and,
I suppose, with Alan Kay) is not useful. You're not going to change
anyone's minds with appeals to authority.

It is fair enough for some person to not care about object orientation. Instead, incorrectly boasting about being an OO expert who writes in an OO language when this languague - Ada - is not an OO language is a bad idea,
so please stop so.

No.

And please learn to use your newsreader properly. Quoted text is conventionally prefixed with "> ", not surrounded by ugly ASCII
boxes. Using a radically different format for your posts just
makes them more difficult to read.

|-------------------------------------------------------------------------|
|"> Cf. a Smalltalk superclass can receive a subclass message for which no|

superclass counterpart exists, so causing a crash. OOP is poop! |

| | |I care even less about Smalltalk. It is about Ada. I explained that your | |suggestion about Ada subclasses evidently wrong." | |-------------------------------------------------------------------------|

I made no "suggestion about Ada subclasses" in this thread, as I clearly referred to an OOP language so clearly excluding Ada. Indeed, you actually quote me saying: "So Ada is not an OOP language."!

This is comp.lang.ada. If you want to compare Ada to other languages,
that's fine. If you want to talk about other languages to the
exclusion of Ada, this is not the place.
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Thu, 21 Aug 2025 01:37:37 +0200, Niocláisín Cóilín de Ghlostéir wrote:

Another thing which he did not do is wanting persons to call circles "squares".

How did you know? Did you ask?
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Wed, 20 Aug 2025 18:54:50 +0000, Kevin Chadwick wrote:

Some people called Ada 83 an "object-based" language, perhaps because
Ada programs typically modelled the real application objects (as
abstract data types) even before tagged types were available.

This guy researched the origins of OOP with a focus on C++ apparently
botching it up. I'm not sure how interesting anyone might find it to
be.

"https://youtu.be/wo84LFzx5nI"

It is with increasing frequency that video presentations, or plain-old
written articles are making these assertions about OOP, and it's origins,
and obvious problems in the context of C++. They all ignore Ada, and the Lisps, and their contributions, and their sound design in the context of
OOP. This is a deliberate, disingenuous attack on the viewer's intellect,
it is an extremely low quality of pedagogy, the only aim of which, is to increase the author's social capital.

Casey's presentation is part of a longer history of their critique on C++ "OOP" (and good on them, because C++ is a stain on the construction of computer science), unfortunately, Casey and the rest stopped being
humorous years ago, and their over-confident conviction, based on a fad to reject critical thinking, and substituting history with their own "modes
of truth", or their "play on words, and meaning" now become insufferable
to observe (mostly because of their emphasis on rhetoric, over reason and logic, draw too many parallels with conservatism, bordering on proto- fascism)—the post-modern condition, what an absurd load of shit the world now produces.
--
To health and anarchy
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

It is with increasing frequency that video presentations, or plain-old >written articles are making these assertions about OOP, and it's origins, >and obvious problems in the context of C++. They all ignore Ada, and the >Lisps, and their contributions, and their sound design in the context of >OOP.

The ignorance of Ada is frustrating but certainly a lot of the newer
languages are avoiding atleast inheritance (Go, Rust, Odin and Zig).
Personally I have only used any OOP features in Dart and Ada. In Dart I
hate the seemingly excessive boiler plate. In Ada I rarely use tagged types
as they are incompatible with sized record representation which I love
(perhaps that has changed recently but I don't think so). I therefore know
little about OOP and I haven't liked inheritance when I have used it. I
also actually found myself disagreeing with Grady Booch objects are a
better way diagrams in his Ada books to be honest though. So the point
about OOP being incompatible with systems thinking might stand.
--
Regards, Kc
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

On Fri, 22 Aug 2025 12:49:54 -0000 (UTC), Kevin Chadwick wrote:

Personally I have only used any OOP features in Dart and Ada. In Dart I
hate the seemingly excessive boiler plate.

Try Python. Both functions and classes are first-class objects, so there
is little or no “boilerplate”.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.ada

This message is in MIME format. The first part should be readable text,
while the remaining parts are likely unreadable without MIME-aware tools.

--708268602-1394750861-1755904878=:2137199
Content-Type: text/plain; CHARSET=UTF-8; format=flowed Content-Transfer-Encoding: QUOTED-PRINTABLE
Content-ID: <c3383f5f-ab41-101f-6f9d-7d0d6a984a69@insomnia247.nl>

On Fri, 22 Aug 2025, Lawrence D=E2=80=99Oliveiro wrote: |-------------------------------------------------------------------------| |"On Fri, 22 Aug 2025 12:49:54 -0000 (UTC), Kevin Chadwick wrote: |
| |

Personally I have only used any OOP features in Dart and Ada. In Dart I| hate the seemingly excessive boiler plate. |

| | |Try Python. Both functions and classes are first-class objects, so there |
|is little or no =E2=80=9Cboilerplate=E2=80=9D." =
| |-------------------------------------------------------------------------|

"How Python and Rust handle errors is entirely different. Python will=20
throw an exception when an error is encountered. Rust will return a value=
=20
when an error is found, while Python will simply throw an error without=20 providing any suggestions on how to fix it. Meanwhile, Rust will provide=20 some recommendations to easily pinpoint and fix the issues."
alleges
Victor Lvovich Porton, "Python vs Rust: Choosing Your Language - Teach=20 Sector", 2022,
HTTPS://TeachSector.com/python-vs-rust-choosing-your-language

"Switch your mind from nervous mode of finding bugs in your Python=20
software (Have you ever mistyped an identifier?) to calm mode of=20 multiparadigm programming language of increased reliability."
says
Victor Lvovich Porton, "Learn D Programming Language for Python=20 programmers", 2025,
HTTPS://TeachSector.com/dforpython

Cf.
"The dynamic nature of Python usually leads to many programming errors in=
=20
Python code, while D usually catches such errors in the compilation=20
stage. This makes it easier to write correct code in D."
alleges
Victor Lvovich Porton, "The Best Python Alternative You Can Find =E2=80=93 = Course=20
and Certifications - Teach Sector", 2025, HTTPS://TeachSector.com/the-best-python-alternative-you-can-find-course-and= -certifications

Cf.
"For OO paradigm it might be important, assuming Python=20
implements them correctly, which I honestly doubt."
says
Dmitry A. Kazakov, "Re: Is Python higher level than Ada?", HTTPS://Usenet.Ada-Lang.IO/comp.lang.ada/o0h7tt$1o9f$1@gioia.aioe.org

Also cf.
Jeffrey R. Carter, "Re: Is Python higher level than Ada?",
Wed, 16 Nov 2016 09:08:37 -0700
Message-ID: <o0i099$fg8$1@dont-email.me>
and
Nasser M. Abbasi, "Java and Python have just discovered=20
"record" type finally after 40 years.",
Fri, 12 May 2023 12:50:14 -0500
Message-ID: <u3lu8o$1p3li$1@dont-email.me> --708268602-1394750861-1755904878=:2137199--
--- Synchronet 3.21a-Linux NewsLink 1.2