Re: Do people who use Ada also use ocaml or F#?

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Le Wed, 03 Nov 2010 14:30:25 +0100, Colin Paul Gloster  
<Colin_Paul_Gloster@acm.org> a écrit:
> HOOD enforces type consistency. Object-oriented languages are weakly
> typed.
Right for HOOD, wrong for OO. OO says nothing about typing, it is all  
about identifying the characteristics of an object at analysis stage and  
about to be able to express it in a language, which may be typed or not.  
If you've seen many untyped OO languages, this is not because OO is not  
typed, but because these languages added some more paradigm to OO to serve  
some targets. I would say : this is not really the language which is OO,  
this is the analysis.

To be honest, the language may provide support, like the minimum required  
for structures, but this not mandatory, as objects may be represented in  
any other way (even with their properties scattered every where in a  
database), and does not do a lot more.

> HOOD does not promote jumping into prototyping. Object-oriented
> systems do not always mature out of prototyping.
Here we are : OO is not prototyping (nor a theory of types), but some  
languages mixed prototyping and OO. Prototyping is indeed the other way  
(and most natural way for human beings) to do without typing, so they may  
be typed OO, and prototyped OO.

> HOOD has generics. Object orientation does not need generics.
I am not sure to see the point, so I will not reply.

> Object orientation supports interactive modifications to the system
> while it is being run, without relying on patches in machine code.
One again, these are other things, not OO.

You may have OO mixed with : dynamic linking, agents, prototypes, types,  
messages passing, method invokation, delegation, inheritance, object as  
class (or class as object), and so on.

OO is like an high level language compared to an assembly language, it was  
created to overcome limits of the classic structural approach which is  
unable to handle/manage large systems (while it is nice for smaller).  
Then, *on top of that*, you may have many things, just like an high level  
language which is not assembly, may be many things (you may not assert a  
lot about a language based on the only fact it is hight level). I also  
feel this is in some way comparable to Ada packages.

To draw a picture

         -> machine code (very early history)
            - tiny-applications
         -> assembly (which some one confuse with machine code)
            - small-applications
            - “coding” is the main matter
              (was created to ease coding, using
               symbols instead of numeric codes)
         -> high level structured language
            - medium to attempted large scale application
            - “coding” is lesser and lesser a matter
              and “analysis” comes in the place
              (structural language gave life to Analysis)
         -> object oriented language
            - “analysis” is clearly the matter, so much
              that it is even done more and more
              early in the application's live, so much
              that it became quite common to do
              analysis while not even a single line
              of source was ever written (!)
            - the old structural languages are always used,
              but they are used to implement OO (you
              will see structural stuff inside of
              object methods)
         -> modeling language (large and/or long life applications)
            - “analysis” is now the only one things : coding ? what
              is this ? OO is always there, plus some other hight
              level paradigm depending on the area (dynamic systems,
              parallel systems, network and web applications, user
              interfaces, intelligent agents, etc).
            - OO is now a bit relegated, to the base components, part
              of the basic alphabet. It turned to be the background
              and the base material (note that even in this
              context, OO still make use of structural languages
              for its own purpose, so it has not disappeared at all).


To be short

           Early time .... -----------> increasing time
           Small system .. -----------> larger system
           Few analysis .. -----------> more analysis up to be the only  
focus

OO is just a stage there (the actual one or the direct-previous one,  
depending on the point of view). With that, it may be typed, none-typed  
(depending on the area), have generic or not, and so on.


-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.