Re: strongly typed langauge

[hbonney@netcom.com (Hugh Bonney)]

Ian Ward (wardi@rsd.bel.alcatel.be) wrote:
: In article 2jh@rc1.vub.ac.be, cagboh@vub.ac.be (AGBOH CHARLES) writes:
: >Could Some explain to me what the term "strongly typed language" is in the
: >context of ada.  Could you give some examples and tips as on how to
: >avoid errors related to this particular domain.

: Ada, as well as other modern languages provides the means of categorising
: data into different types which have entirely or partly different meanings
: to other types within the same program.

: The easiest example I can think of is this :

: Suppose I have two numbers

: The first one is five, and it is the number of children, under ten
: in England, who have behaved themselves at school since the 1976
: decision by Strasbourg to ban corporal punishment in schools was
: enforced.

: The second number is 1200, this is the number of seconds it takes
: to drink a pint of beer, say.

: So we have two numbers, 1200 and 5, which we add together.

: 1200 + 5 = 1205.

: 1205 what, this clearly makes no sense...

    Well, of course it does since the sum is well known to be a
    physical constant. 

    Another example might be to note that it's 2km from A to B,
    300m from B to C, and 20mm from C to D. So if you walk from
    A to D have you gone a distance of 322? In elementary school
    we have to learn the essentials of data typing and one can 
    start with that. It does make sense to add apples and oranges
    sometimes, but it doesn't make sense to add km and mm even
    if you want to know the distance from Paris to the end of
    your nose.

    With all that, I do a lot of programming on the hardware. 
    Lately I've been writing up a boot rom almost entirely in
    C . Because the on-chip peripheral control registers are 
    all memory mapped, there are almost no asm statements 
    anywhere. There's one little chunk to save and restore
    all the processor registers and a few bits here and there
    including an equivalent of a simple crt0 to pass control 
    to an RTOS.  In some other languages it would have been 
    necessary to write very large chunks in assembler which
    would escape task-level type checking entirely. There must 
    be some code around that is known to be absolutely wonderful -
    but is running on a rather shakey substrate.

    Strong typing shouldn't be used as a substitute for thought
    or care, where it's useful is in pointing out real difficulties
    in either one person's thinking about a problem, or real
    (and inevitable) differences in understanding from one person
    to the next. One could have such a code inspection done by
    an inspection program, of course, incorporating every type of
    analysis that will execute by overnight, and going through all
    the code in a project as well as pieces of it.


: It is therefore totally stupid, and no-one would ever want
: to add five children, to a time. However, both of these numbers
: are simple integers, and after six years on a project, when 
: one's wife has just left you, and one has a particularly bad
: hangover, one is likely to accidentally add these two numbers
: together. In fact this will happen all over your project, 
: some will get spotted, some shall not. Some will be caught
: during testing, some shall not. Some will get to the customer.

: In a language that does not define strong type checking, then
: there is generally less chance that this mistake will be caught.
: Unfortunately, the chinese? proverb "One's laces do not snap
: until they are really needed." comes into play.

: In essence, strong typing is just this, it is the software
: engineering technique which stops the user from multiplying
: a record by an array; dividing the time by a colour; or
: passing a string variable into a procedure which expects 
: an integer.

: Because Ada defines this as part of the language definition,
: it allows the programmer to create conceptual types within
: the language which are fundamentally different in what they
: represent. The language knows what sensible operations can
: be performed on these types, and it knows what is stupid.
: (What is stupid is defined by the rules of the language,
: this doesn't mean the rules can be contravened, but the
: programmer cannot avoid knowing he is doing it.)

: Some people see these restrictions as a disadvantage, but,
: as compilers provide such strong semantic checking, it can
: be used to the programmer's advantage.

: When faced with a data type such as an array of continents,
: containing, a record containing, land area, number of vehicles,
: an array of countries etc.

: Each country in this array contains an array of animals, and
: each animal contains a record, with number of legs, how many in 
: existance etc.

: Experienced Ada programmers, (well, ok, _I_) use the strong type
: checking to their advantage here. They just type in any old
: shit such as

: ...
:    TOO_FEW_LEOPARDS := THIRTY; 
:    -- TOO_FEW_LEOPARDS is of cunning type ANIMALS_COUNT, thirty is
:    -- a constant := 30;

:    if EARTH(AFRICA).ANIMALS.number_of_legs < TOO_FEW_LEOPARDS
:    then

:        -- invoke yield management
:        PUT_UP_PRICE_OF (LEOPARD_SKIN_COATS);

:    end if;
: ...
: ---

: Throw this at the compiler, and hey presto before animal
: rights campaigner have even written out the billboards to
: campaign outside your shop, the compiler will turned around
: and said. "EARTH" is a record, unlucky, perhaps you meant
: EARTH.INCONTINENTS (AFRICA). so you go and change it.
: and the compiler says

: EARTH.INCONTINENTS (AFRICA) is a record, perhaps you meant
: EARTH.INCONTINENTS (AFRICA).COUNTRIES....

: So you change it, 
: and it says

: until eventually it says ...
: .....NUMBER_OF_LEGS is not of the same type as TOO_FEW_LEOPARDS

: So you change, and you still haven't had to think about the
: code yet, and you recompile, and it compiles, and you run it,
: and it runs, and you don't even have to start up the debugger.
: Amazing huh?
: Hey presto.  Congratulations, you've just finished early.

   Air Traffic Controllers in Europe must get interesting messages
   from their systems...

: So you have the afternoon off, and get stabbed by some twelve year
: old kid, on his way back from the European court of human rights,
: having just won the right to stab anybody, without being told off
: by his stepdad.

: Ian Ward's opinions only : wardi@rsd.bel.alcatel.be