From: Piet van Oostrum on
>>>>> "Tassilo v. Parseval" <tassilo.von.parseval(a)rwth-aachen.de> (TvP) wrote:

>TvP> Most often, languages with strong typing can be found on the functional
>TvP> front (such as ML and Haskell). These languages have a dynamic typing
>TvP> system.

What do you mean with: 'Haskell has a dynamic typing system'?
--
Piet van Oostrum <piet(a)cs.uu.nl>
URL: http://www.cs.uu.nl/~piet [PGP]
Private email: piet(a)vanoostrum.org
From: Roy Smith on
"Xah Lee" <xah(a)xahlee.org> wrote:
> Joe: lang x is strongly typed
> Dave: you mean statically typed?
> John: no no, that's weakly typed.
> Mike: actually, it is dynamically typed!

I used to have a bunch of comp sci questions I would ask interview victims.
One of them was "what does it mean when a language is strongly typed?" I
once had somebody tell me it meant the language had long variable names,
and thus took a lot of typing.
From: Paul Rubin on
Roy Smith <roy(a)panix.com> writes:
> I used to have a bunch of comp sci questions I would ask interview victims.
> One of them was "what does it mean when a language is strongly typed?" I
> once had somebody tell me it meant the language had long variable names,
> and thus took a lot of typing.

But that's incorrect. Strong typing means there's a lot of variables
whose names are in ALL CAPS.
From: Piet van Oostrum on
>>>>> "Xah Lee" <xah(a)xahlee.org> (XL) wrote:

>XL> Joe: lang x is strongly typed
>XL> Dave: you mean statically typed?
>XL> John: no no, that's weakly typed.

That should have been `weekly typed', according to the link below.
Maybe there is also `daily typed' or `monthly typed'?

>XL> http://xahlee.org/UnixResource_dir/writ/jargons.html

--
Piet van Oostrum <piet(a)cs.uu.nl>
URL: http://www.cs.uu.nl/~piet [PGP]
Private email: piet(a)vanoostrum.org
From: Xah Lee on
The Rise of “Constructors” and “Accessors”

A instantiation, is when a variable is assigned a super-subroutine
(class). A variable assigned such a super-subroutine is now called a
instance of a class or a object.

In OOP practice, certain inner-subroutines (methods) have developed
into specialized purposes. A inner-subroutine that is always called
when the super-subroutine is assigned to a variable (instantiation), is
called a constructor or initializer. These specialized
inner-subroutines are sometimes given a special status in the language.
For example in Java the language, constructors are different from
methods.

In OOP, it has developed into a practice that in general the data
inside super-subroutines are supposed to be changed only by the
super-subroutine's inner-subroutines, as opposed to by reference thru
the super-subroutine. (In OOP parlance: class's variables are supposed
to be accessed/changed only by the class's methods.) Though this
practice is not universal or absolute. Inner-subroutines that change or
return the value of variables are called accessors. For example, in
Java, a string class's method length() is a accessor.

Because constructors are usually treated as a special method at the
language level, its concept and linguistic issues is a OOP machinery
complexity, while the Accessor concept is a OOP engineering complexity.

-----
to be continued tomorrow.

This is part of an installment of the article
“What are OOP's Jargons and Complexities”
by Xah Lee, 20050128. The full text is at
http://xahlee.org/Periodic_dosage_dir/t2/oop.html

© Copyright 2005 by Xah Lee. Verbatim duplication of the complete
article for non-profit purposes is granted.

The article is published in the following newsgroups:
comp.lang.c,comp.lang.c++,comp.lang.lisp,comp.unix.programmer
comp.lang.python,comp.lang.perl.misc,comp.lang.scheme,comp.lang.java.programmer
comp.lang.functional,comp.object,comp.software-eng,comp.software.patterns

Xah
xah(a)xahlee.org
∑ http://xahlee.org/

First  |  Prev  |  Next  |  Last
Pages: 1 2 3 4 5 6 7 8 9 10 11 12
Prev: swift MT940 files
Next: Is there neq for strings?