Duck typing alows true polymorfisim

[atbusbook@aol.com]

lets say you want a generic numerical algorithom like sum

Ruby

def sum lst
lst.inject(0){| total,current| total*current}
end

Java // i dont know if there is a numeric super class for numbers

class Sum{
public static int sum(int[] lst){
int total = 0;
for(int current : lst){
total+=current;
}
return total;
}
// repeat for all other number types
}

[Simon Forman]

Re: Duck typing alows true polymorfisim

atbusbook@aol.c om wrote:

lets say you want a generic numerical algorithom like sum
>
Ruby
>
def sum lst
lst.inject(0){| total,current| total*current}
end
>
Java // i dont know if there is a numeric super class for numbers
>
class Sum{
public static int sum(int[] lst){
int total = 0;
for(int current : lst){
total+=current;
}
return total;
}
// repeat for all other number types
}

What's your question? (Or, if no question, point?) :-)

Totally off topic (and indeed "off-list"..) is that really how ruby
sums a list? How does that work? Doesn't the '*' mean multiply? and
what are the pipe symbols for? (Feel free to ignore these questions. I
should really go look it up myself if I'm so curious..)

Peace,
~Simon

[John Bokma]

Re: Duck typing alows true polymorfisim

atbusbook@aol.c om wrote:

lets say you want a generic numerical algorithom like sum

Hmmm, I thought you were going to announce that you were the first born
son of Xah Lee. Actually you did!

--
John MexIT: http://johnbokma.com/mexit/
personal page: http://johnbokma.com/
Experienced programmer available: http://castleamber.com/
Happy Customers: http://castleamber.com/testimonials.html

[David Ells]

Re: Duck typing alows true polymorfisim


atbusbook@aol.c om wrote:

lets say you want a generic numerical algorithom like sum
>
Ruby
>
def sum lst
lst.inject(0){| total,current| total*current}
end
>
Java // i dont know if there is a numeric super class for numbers
>
class Sum{
public static int sum(int[] lst){
int total = 0;
for(int current : lst){
total+=current;
}
return total;
}
// repeat for all other number types
}

Any more to add? Your question is not exactly clear. Are you asking how
to do higher order procedures in Python? Here's sum as a higher-order
procedure... It sums the numbers from a to b (or any thing that can be
compared and added with "<" and "+").

def Sum(term, next, a, b):
if(a b):
return 0
else:
return (term(a) + (Sum(term, next, next(a), b)

This function takes two functions (term and next) and two objects (in
our case numbers) representing the range to sum across. Now let's say
you want to add the numbers 1 through 10. The term for the summation
would just be the number, so the term function would simply be a
function called identity, and could be defined as

def identity(x):
return x

To get the next term, we are just adding one each time (i.e. 1, 2, 3,
4, ...). So our next function is

def increment(x):
return x += 1

Then we call Sum(identity, increment, 1, 10), and we get 1 + 2 + 3 + 4
+ and so on.

Now what if you wanted the sum of the CUBES of 1 through 10? Easy, we
replace the term function with a function cube(x) that returns x*x*x.

Sum(cube,increm ent,1,10)

Hence each term in our summation is the cube, but we are still
incrementing by one each time, so we get (1^3 + 2^3 + 3^3 + 4^3 + ...)

Similarly we can change the next function to skip certain number, meet
certain requirement, do some tranformation, whatever. The fact that
python accept and uses functions as parameters to other functions is
awesome in terms of power, but it can get a little mind boggling
sometimes.

[atbusbook@aol.com]

Re: Duck typing alows true polymorfisim

What was i thinkinng repace * with + i was'nt thinking i origanaly
thaught of sum of squares so i put a * insted of a +

[Simon Forman]

Re: Duck typing alows true polymorfisim

atbusbook@aol.c om wrote:

What was i thinkinng repace * with + i was'nt thinking i origanaly
thaught of sum of squares so i put a * insted of a +

But again, what's your question?

[Terry Reedy]

Re: Duck typing alows true polymorfisim


"David Ells" <ells.david@gma il.comwrote in message
news:1156534086 .698353.81850@m 73g2000cwd.goog legroups.com...

def increment(x):
return x += 1

'return x+1' works better ;-)

tjr

[The Ghost In The Machine]

Re: Duck typing alows true polymorfisim

In comp.lang.java. advocacy, atbusbook@aol.c om
<atbusbook@aol. com>
wrote
on 25 Aug 2006 12:05:21 -0700
<1156532721.879 808.40990@i3g20 00cwc.googlegro ups.com>:

lets say you want a generic numerical algorithom like sum
>
Ruby
>
def sum lst
lst.inject(0){| total,current| total*current}
end
>
Java // i dont know if there is a numeric super class for numbers
>
class Sum{
public static int sum(int[] lst){
int total = 0;
for(int current : lst){
total+=current;
}
return total;
}
// repeat for all other number types
}
>

There isn't; Java makes the distinction between an int and
an Integer, a double and a Double. Java 5 did introduce
autoboxing, which makes things like

Number[] numbers = new Number[]{1, 2.3, 4, 5.6};

possible, and Number is a baseclass for both Integer and
Double (but not int and double).

Therefore, one could write:

public class Sum {
public static double sum(int[] lst)
{
Number[] nlst = new Number[lst.length];
for(int i = 0; i < nlst.length; i++) nlst[i] = new Integer(lst[i]);
return sum(Arrays.asLi st(nlst));
}
public static double sum(double[] lst)
{
Number[] nlst = new Number[lst.length];
for(int i = 0; i < nlst.length; i++) nlst[i] = new Double(lst[i]);
return sum(Arrays.asLi st(nlst));
}
public static double sum(float[] lst)
{
Number[] nlst = new Number[lst.length];
for(int i = 0; i < nlst.length; i++) nlst[i] = new Double(lst[i]);
return sum(Arrays.asLi st(nlst));
}
public static double sum(Number[] lst)
{
return sum(Arrays.asLi st(lst));
}
public static double sum(Collection< Numberlst)
{
double sum = 0;
for(Iterator<Nu mberi = lst.iterator(); i.hasNext())
sum += i.next().double Value();
return sum;
}

}

A rather ugly but possibly useful duckling.

--
#191, ewill3@earthlin k.net
Windows Vista. Because it's time to refresh your hardware. Trust us.

[Dan Johnson]

Re: Duck typing alows true polymorfisim

<atbusbook@aol. comwrote in message
news:1156532721 .879808.40990@i 3g2000cwc.googl egroups.com...

lets say you want a generic numerical algorithom like sum
>
Ruby
>
def sum lst
lst.inject(0){| total,current| total*current}
end
>
Java // i dont know if there is a numeric super class for numbers

[snip- int only example]

There is, and it is interesting because it hilights the
real difference: Java uses C style numerics, where
you select the model of arithmetic you want using
the type system. Here's a 'generic sum' for Java:

public static double sum(Iterable<? extends Numberlist)
{
double total=0;
for(Number n : list)
double+=n.doubl eValue();
return total;
}

If I got it right (I'm a bit rusty with Java) that will sum
any collection containing any kind of number.

But you have to specify that you want *double* arithmetic,
as you see; had I chosen int, it would produce different
answers.

In some languages- like Ruby I think- you cannot make
this choice. Your language chooses for you. Most languages
that do this prefer accuracy to speed, so everything gets
promoted to larger types on demand, and things like
rounding and overflow are avoided.

However, even if you agree with this choice, you can
still get into trouble. Promoting to 'double' or 'float'
imposes different errors that you'd get with ints, but
they still exist. Sometimes a ratio type is better; other
times you would prefer a decimal type.

The greatest advantage of static type systems is to
expose design decisions like these in a way the
compiler can see.

[David Ells]

Re: Duck typing alows true polymorfisim


Terry Reedy wrote:

"David Ells" <ells.david@gma il.comwrote in message
news:1156534086 .698353.81850@m 73g2000cwd.goog legroups.com...

def increment(x):
return x += 1

>
'return x+1' works better ;-)
>
tjr

Heh, woops... thanks

[Jeroen Wenting]

Re: Duck typing alows true polymorfisim


"Simon Forman" <rogue_pedro@ya hoo.comwrote in message
news:1156533807 .630662.12330@i 42g2000cwa.goog legroups.com...

atbusbook@aol.c om wrote:

>lets say you want a generic numerical algorithom like sum
>>

What's your question? (Or, if no question, point?) :-)
>

Reads like the weekly "Ruby is better than Java because XXXXX" post.

[The Ghost In The Machine]

Re: Duck typing alows true polymorfisim

In comp.lang.java. advocacy, Jeroen Wenting
<jwenting>
wrote
on Wed, 30 Aug 2006 20:18:52 +0200
<12fblk87ppk7ie f@corp.supernew s.com>:

>
"Simon Forman" <rogue_pedro@ya hoo.comwrote in message
news:1156533807 .630662.12330@i 42g2000cwa.goog legroups.com...

>atbusbook@aol.c om wrote:

>>lets say you want a generic numerical algorithom like sum
>>>

>

>What's your question? (Or, if no question, point?) :-)
>>

Reads like the weekly "Ruby is better than Java because XXXXX" post.
>

Well, FWIW one could throw this into the pot and watch it explode:

http://www.approximity.com/ruby/Comparison_rb_st_m_java.html

:-)

This table needs some work. The leftmost column is
unidentified, for example ("Capability " or "Feature"
suggests itself here) and each of these capabilities or
features should probably have a link to a short description
of the capability or feature, preferably with an example.

Also, one language is very conspicuous by its absence: C#.
One could also add C, Basic, and ISO Pascal; the first is
widely used but lacks polymorphism, inheritance, dynamic
casting, etc., and the last is probably not used anywhere
in its form (though dialects are plenty), since one can't
do anything *with* it, really -- though IIRC someone has
told me it can at least open an arbitrary file now, as
opposed to having the user pass one down in the program
identifier list. :-)

As for the middle one: which dialect? Was it ever
standardized? Visual Basic is a very object-oriented
language in spots, but it's not the only variant; I
used to use at least 4 other variants off and on:

GWBasic -- old IBM PCs
ABasic -- Amiga variant
AmigaBasic -- Microsoft-sponsored Amiga variant
HP Basic (?) -- load tape into very old HP 21xx-series
computer and one had a multitasking Basic which could
do the simpler stuff, but its error diagnostics were
pure numeric: ERROR 67 IN LINE 20. Fortunately, we
had plenty of pamphlets detailing the errors.

Also, Java now has templates. (The implementation is
pretty gross and has some quirks, IMO, but it's better
than nothing.) C++ has a typing system ("type_of" or
some such; I'd have to look) which yields little
more than the mangled type name and static inheritance
testing capabilities. Of course C++ doesn't have
dynamic inheritance anyway.

One could include additional capabilities:

Dynamic type creation. I don't know if Java has this or not.
One can of course attempt bytecode synthesis -- I think that's
what BCEL uses -- but that's a bit of a hack.

Dynamic method creation. Java does *not* have this. AIUI
Smalltalk-80 does; one can take an existing class and add
methods thereto.

Dynamic method override. This may be an artificial distinction
but in some languages -- Smalltalk-80 again, presumably -- one
can take an existing method implementation and override it in
the same class, but without allowing the creation of new methods.
How this would be enforced without additional keywords and/or
a full-fledged ACL method/metadata system, I for one do not know.

Dynamic method deletion. I for one might only want this in
the context of a "sandbox" but if one can create methods,
one should be able to delete them as well if only because
of undo.

Dynamic method rename. This could lead to much madness
but this might be useful during sandboxing.

Dynamic method signature changing. Eclipse has a
reasonable way of doing it using source but I'll admit to
wondering whether it makes sense given a Method descriptor
whether one should be able to edit (as opposed to viewing
or invoking) that descriptor, and when. One might implement
this as a new method, followed by a delete of the old one.

Dynamic other method deletion. If one can delete one's own
methods in an edit session, should it be possible to delete
others' methods too? An interesting question.

Dynamic inheritance. For those languages that support
inheritance one might liken it to changing what the
language inherits or implements on the fly. I don't
know of any language apart from Smalltalk that can even
think about allowing dynamic inheritance, but it's a thought.

Operator overload (e.g., C++'s operator ==()).

Name overload. C does not have it; C++ and Java do. I suspect
Ruby and Python do as well.

Globals. Java has no globals as such, unless one counts
class names. C is all globals, unless one counts statics.

Unnamed classes. new Runnable() { public void run() {...} }
is Java's contribution. Can be useful.

Nested classes.

Primitive types -- in other words, the int<->Integer
dichotomy we all know and love in Java; such also exists
in C++ and IINM C#. I'm not sure if Smalltalk has such
a concept, or not; Smalltalk allows overrides on numbers.
(In Java one might contemplate 2.toString(), for example!)

Arbitrary integer size. The only language I know having this
is Common LISP.

Explicit module-level identifier scoping. In C++ this
might be implemented during link using the -E flag on ld,
for example (there is the Microsoft concept of exporting
in their DLLs, which is vaguely similar as well).
An identifier could be "global" in the module but
inaccessible to those outside of the module. Modules
can include other modules in C++, which makes life
even more interesting. (This might be more of an
environmental versus a language issue.)

Thread-level variable/value scoping. In Java this is done
using the ThreadLocal class, but is not (AFAICT) supported
by the language proper. This of course differs from
call-level (stack), global-level, and class-level scoping.
One might even contemplate function-level scoping, but
that would only be useful if one can create new functions
on the fly and modify these values; otherwise, they might
as well be static.

Persistability. In Java one can implement Serializable
or Externalizable, and generate output from an object.
I've always considered this a bit of a weird hack but it
can come in handy, and forms one leg of the Java EJB
implementation.

Transient field. In Java a capability exists to mark a
field as transient, which is a hint during serialization
that this field in a class not be persisted. (One can
check for this using the Modifier.TRANSI ENT bit.)

Volatile field. In Java there is a volatile keyword. I
don't know its precise semantics but it applies to fields.

Virtuals. In C++ one must explicitly declare a function
virtual; C has none at all, and in Java one must explicitly
declare a function final (disallowing overrides) and cannot
really disable a non-method's "virtuality " at all.

Pure/abstract virtuals. C++ has the "=0" construct; Java
has the abstract keyword.

Static virtuals.

Delegates. This Microsoftish concept is a bit hard for me
to pin down (it feels a lot like a C++ method pointer --
or even a C function pointer) but is occasionally touted
as an advantage for such languages as C++ and the ill-fated
Java++, which had them as part of the language.

First-level object functions. AIUI, this is a high-level
concept which would allow for constructs in a hypothetical
language such as

k = (f @ g)(s1,s2,s3);

if f has arguments (int v) and g has arguments (string s1, string s2,
string s3). It would also allow for constructs such as

h = f @ g;

where h is a "function variable" of some sort -- and it would have
the same signature as g. (The '@' is used in lieu of 'o', although
one might use character U+2218 (ring operator) in a theoretical
language where everyone understands Unicode.)

C#'s event handling emulates this concept to some extent
using the += operator, though I doubt they do it all that
generally -- or all that well.

Function-function operators. Under certain conditions the
construct f + g makes sense, if they have compatible signatures;
one might even write

int (f + g)(int a)
{
return f(a) + g(a)
}

Ditto for f - g, f * g, and even f += g if f returns a reference.
One can also contemplate unary operators such as '-f' .

Set/collection union/intersection/subtraction/element
of support. This is probably most useful for hard-core
mathematicians and database junkies. :-) In Java one
might declare a Union class easily enough, which takes
two collections and tries to do something intelligent with
them during a scan with the iterator, and of course
the .contains() method is good enough for now.

Integrated database access (and how tightly). C++ has
none at all, though of one can use various third-party
libraries. Java has some base-level API -- the java.sql.*
and javax.sql* library. I suspect C#'s access is similar;
I don't know regarding Ruby. A variant of COBOL was
able to access the database -- DEC's DBMS product,
which was a CODASIL affair -- by using statements in
the language itself. Nowadays, apparently, such are
considered slightly problematic, mostly because DB defs
change a little too often.

Arbitrary iterator positioning. In C++ some collections
can position an iterator in an arbitrary location within
the collection -- the only obvious one would be arrays.
The closest one might get in current Java is to do a
head(), tail(), or subset() and iterate over that.

GUI support -- this is primarily API/library but might
be put in the language if it makes sense -- perhaps when
combined with collections and sets (e.g., is a point
within a rectangle?), though there are some issues such
as whether one would want to enumerate all the elements
in a collection (points in a rectangle).

There's probably a number I've missed but there are
some interesting and somewhat unexplored directions in Java.
Whether it makes sense to explore them is not clear to me.

--
#191, ewill3@earthlin k.net
Windows Vista. Because it's time to refresh your hardware. Trust us.

[Tor Iver Wilhelmsen]

Re: Duck typing alows true polymorfisim

The Ghost In The Machine <ewill@sirius.t g00suus7038.net writes:

Also, one language is very conspicuous by its absence: C#.

He does not date any of the updates, so it's unclear how recently it
has been updated (a lot of the web is stale, like a rotting tree in a
forest.)

AmigaBasic -- Microsoft-sponsored Amiga variant

Well, at the time Microsoft were the makers of the de-facto BASIC
implementations - M-BASIC for CP/M, the various variants in VC-20 and
C-64 and later derivates of those, and many other home computers.
"Sponsored" should probably be "created" instead - I assume they were
paid for the job.

Also, Java now has templates. (The implementation is pretty gross
and has some quirks, IMO, but it's better than nothing.) C++ has a
typing system ("type_of" or some such; I'd have to look) which
yields little more than the mangled type name and static inheritance
testing capabilities. Of course C++ doesn't have dynamic inheritance
anyway.

There's the virtual stuff, and you could conceivably implement dynamic
inheritance via the bare-bones C layer - like function pointers. The
type information in C++ (RTTI) is optional.

Dynamic type creation. I don't know if Java has this or not. One can
of course attempt bytecode synthesis -- I think that's what BCEL
uses -- but that's a bit of a hack.

Groovy could possibly be used for that; also IIRC Java 6 adds some
features for that. I seem to recall security implications being one
reason this ability wasn't included from the start.

Dynamic method creation. Java does *not* have this. AIUI
Smalltalk-80 does; one can take an existing class and add methods
thereto.

Yes, but that's because a Smalltalk program lives inside a big binary
"image" that is mutable. Woe unto you if that big binary file gets
corrupted.

Dynamic method deletion. I for one might only want this in the
context of a "sandbox" but if one can create methods, one should be
able to delete them as well if only because of undo.

The problem with deleting a method is whether the runtime can handle
it: Smalltalk has doesNotUndersta nd:#aMessage, Java has
NoSuchMetohdErr or - what does C++ do? A zeroed virtual method would
cause a pure virtual method call error, which I guess C++ programmers
are trained to take into account. Also, if class A has a method and
you delet it in subclass B, it breaks the Liskov Substitution
Principle, there B should be able to function where an A is wanted.

Dynamic method rename. This could lead to much madness but this
might be useful during sandboxing.

A method's name and its "address" are distinct, but for dynamic method
dispatch, what about any other code that doesn't know the new name but
assumes the method is called the same?

Dynamic inheritance. For those languages that support inheritance
one might liken it to changing what the language inherits or
implements on the fly. I don't know of any language apart from
Smalltalk that can even think about allowing dynamic inheritance,
but it's a thought.

If you can change a Perl class, er, module's @INC array I think that
would support it.

Operator overload (e.g., C++'s operator ==()).

Or rather "dotless/prefix method invocation with the added baggage of
precedence rules". Smalltalk solves this by 1) not having those
precedence rules, 2) have dotless method invocation and 3)

>
Name overload. C does not have it; C++ and Java do. I suspect Ruby
and Python do as well.

Are you referring to namespaces, ie. namespace isolation?

Globals. Java has no globals as such, unless one counts class names.
C is all globals, unless one counts statics.

Even the fully qualified classes are only "global" in the context of a
classloader and whatever classloaders it delegates to.

Unnamed classes. new Runnable() { public void run() {...} } is
Java's contribution. Can be useful.

Well, they do end up with a name after compilation. And you do not
want to open that can of worms since then you end up with Ruby and
Smalltalk users dragging out closures and C# and Lisp users dragging
out lambdas... :)

Nested classes.

Generally that's just a namespace issue. In Java, a class Fie nested
inside Foo is the top-level class Foo$Fie with some compiler magic to
ensure it's used correctly, which leads to funny stuff like

Foo.Fie object = new Foo().new Fie();

which gets turned into the bytecode equivalent of

Foo$Fie object = new Foo$Fie(new Foo());

Primitive types -- in other words, the int<->Integer dichotomy we
all know and love in Java; such also exists in C++ and IINM C#. I'm
not sure if Smalltalk has such a concept, or not; Smalltalk allows
overrides on numbers. (In Java one might contemplate 2.toString(),
for example!)

In Smalltalk you ask the 1 object to count to 10 for a loop. It makes
sense there, it would not feel "right" in the C family...

Arbitrary integer size. The only language I know having this is
Common LISP.

java.math.BigIn teger, but the operations you can perform are limited.

Thread-level variable/value scoping. In Java this is done using the
ThreadLocal class, but is not (AFAICT) supported by the language
proper.

Yes, and that leads to a problem where if you forget to null a
ThreadLocal you can "leak" objects.

One might even contemplate function-level scoping, but that would
only be useful if one can create new functions on the fly and modify
these values; otherwise, they might as well be static.

As long as you make sure you never use a private static member
elsewhere than in that particular method, it can play the role of a
function-level method.

Persistability. In Java one can implement Serializable or
Externalizable, and generate output from an object. I've always
considered this a bit of a weird hack but it can come in handy, and
forms one leg of the Java EJB implementation.

Persistability is left as an excercise to libraries in most languages.

Volatile field. In Java there is a volatile keyword. I don't know
its precise semantics but it applies to fields.

In Java it's generally a hint to the optimizer NOT to optimize away or
make any assumptions about access to a field.

C#'s event handling emulates this concept to some extent using the
+= operator, though I doubt they do it all that generally -- or all
that well.

Well it's closer to a list of function pointers, sorry delegates; not
much more than Java's more explicit (or cumbersome if you like) event
interfaces can do.

Integrated database access (and how tightly). C++ has none at all,
though of one can use various third-party libraries. Java has some
base-level API -- the java.sql.* and javax.sql* library.

Well, those are general library APIs that require native or
socket-based implementation by vendors or third parties.

What you talk about is better represented by "inline" SQL in the form
of SQLJ or Oracle's Pro*C and related products.

It boils down to how much should be in the language (syntax, compiler,
runtime) and how much should be left to libraries. E.g. he has a "no"
for garbage collection in C++, but there are libraries for that sort
of thing (relying mostly on the ability to override the new, delete
and assignment operators. Even in Java you often have a choice of
garbage collector algorithms in a runtime.

[The Ghost In The Machine]

Re: Duck typing alows true polymorfisim

In comp.lang.java. advocacy, Tor Iver Wilhelmsen
<jadedgamer@hot mail.com>
wrote
on 31 Aug 2006 18:31:15 +0200
<uzmdklve4.fsf@ hotmail.com>:

The Ghost In The Machine <ewill@sirius.t g00suus7038.net writes:
>

>Also, one language is very conspicuous by its absence: C#.

>
He does not date any of the updates, so it's unclear how recently it
has been updated (a lot of the web is stale, like a rotting tree in a
forest.)

Aye; my webpage has a similar problem. :-)

>

>AmigaBasic -- Microsoft-sponsored Amiga variant

>
Well, at the time Microsoft were the makers of the de-facto BASIC
implementations - M-BASIC for CP/M, the various variants in VC-20 and
C-64 and later derivates of those, and many other home computers.
"Sponsored" should probably be "created" instead - I assume they were
paid for the job.

OK, "created" then. :-)

>

>Also, Java now has templates. (The implementation is pretty gross
>and has some quirks, IMO, but it's better than nothing.) C++ has a
>typing system ("type_of" or some such; I'd have to look) which
>yields little more than the mangled type name and static inheritance
>testing capabilities. Of course C++ doesn't have dynamic inheritance
>anyway.

>
There's the virtual stuff, and you could conceivably implement dynamic
inheritance via the bare-bones C layer - like function pointers. The
type information in C++ (RTTI) is optional.

Oh yeah, that's true. Still not all that dynamic, though, unless
one recompiles.

>

>Dynamic type creation. I don't know if Java has this or not. One can
>of course attempt bytecode synthesis -- I think that's what BCEL
>uses -- but that's a bit of a hack.

>
Groovy could possibly be used for that; also IIRC Java 6 adds some
features for that. I seem to recall security implications being one
reason this ability wasn't included from the start.

Not familiar with Groovy; I'll have to look into that.
It's amazing what's out there; one of the problems with
Free Open Source Software (FOSS) is that there's multiple
choices for the obvious stuff. :-)

>

>Dynamic method creation. Java does *not* have this. AIUI
>Smalltalk-80 does; one can take an existing class and add methods
>thereto.

>
Yes, but that's because a Smalltalk program lives inside a big binary
"image" that is mutable. Woe unto you if that big binary file gets
corrupted.

Indeed.

I for one would want Smalltalk to have the ability to
transcript certain messages but would have to look.
(One might call that an edit audit trail.)

>

>Dynamic method deletion. I for one might only want this in the
>context of a "sandbox" but if one can create methods, one should be
>able to delete them as well if only because of undo.

>
The problem with deleting a method is whether the runtime can handle
it: Smalltalk has doesNotUndersta nd:#aMessage, Java has
NoSuchMetohdErr or - what does C++ do? A zeroed virtual method would
cause a pure virtual method call error, which I guess C++ programmers
are trained to take into account.

I'd frankly have to look. My thinking is that it's a message followed
by an exit().

Also, if class A has a method and
you delet it in subclass B, it breaks the Liskov Substitution
Principle, there B should be able to function where an A is wanted.

Heh...an interesting name; I'm not familiar with that
issue. Of course it's important for B to be an A in
many cases, though AFAICT usually what happens is that
A declares a method virtual with an implementation and B
munges it.

>

>Dynamic method rename. This could lead to much madness but this
>might be useful during sandboxing.

>
A method's name and its "address" are distinct, but for dynamic method
dispatch, what about any other code that doesn't know the new name but
assumes the method is called the same?

What indeed? Much madness.

>

>Dynamic inheritance. For those languages that support inheritance
>one might liken it to changing what the language inherits or
>implements on the fly. I don't know of any language apart from
>Smalltalk that can even think about allowing dynamic inheritance,
>but it's a thought.

>
If you can change a Perl class, er, module's @INC array I think that
would support it.
>

>Operator overload (e.g., C++'s operator ==()).

>
Or rather "dotless/prefix method invocation with the added baggage of
precedence rules". Smalltalk solves this by 1) not having those
precedence rules, 2) have dotless method invocation and 3)

....?

I'll admit Smalltalk has a lot of things, but popularity isn't
unfortunately one of them. :-/

>

>>
>Name overload. C does not have it; C++ and Java do. I suspect Ruby
>and Python do as well.

>
Are you referring to namespaces, ie. namespace isolation?

Hmm...that could use clarification. The general idea is that
Java and C++ allow

void routine1(const char *);
void routine1(int);
void routine1(double );

in the same module or class.

I suppose a slightly better term would be "function overloading", since
that's what it was called some time back.

C does not have this capability, and it occasionally leads to problems
if a program doesn't use proper design methods (such as declaring all
methods in .h files and including them, as opposed to putting local
extern signatures in the .C code -- yes, my prior employer had code
that did exactly that for awhile; hopefully it's cleaned up by now since
it's been almost 6 years :-) ).

>

>Globals. Java has no globals as such, unless one counts class names.
>C is all globals, unless one counts statics.

>
Even the fully qualified classes are only "global" in the context of a
classloader and whatever classloaders it delegates to.

Good point.

>

>Unnamed classes. new Runnable() { public void run() {...} } is
>Java's contribution. Can be useful.

>
Well, they do end up with a name after compilation.

Picky, picky. :-) In any event the name is not available
to the program source; one can't expect to do things like

Runnable$1 r = new Runnable() { public void run() {...} }

and hope for it to work. One might be able to do something
slightly silly like

Class c = Class.forName(" Runnable$1");

c.newInstance() ;

but for Java that's slightly problematic, especially if there's
more than one Runnable in that class.

And you do not
want to open that can of worms since then you end up with Ruby and
Smalltalk users dragging out closures and C# and Lisp users dragging
out lambdas... :)

Yes, well AFAICT a closure is some code with a little context; in Java
some of the context is required to have final variables, or a method by
which it can pick up its owning class's members or call its routines.

>

>Nested classes.

>
Generally that's just a namespace issue. In Java, a class Fie nested
inside Foo is the top-level class Foo$Fie with some compiler magic to
ensure it's used correctly, which leads to funny stuff like
>
Foo.Fie object = new Foo().new Fie();
>
which gets turned into the bytecode equivalent of
>
Foo$Fie object = new Foo$Fie(new Foo());

Hm.

>

>Primitive types -- in other words, the int<->Integer dichotomy we
>all know and love in Java; such also exists in C++ and IINM C#. I'm
>not sure if Smalltalk has such a concept, or not; Smalltalk allows
>overrides on numbers. (In Java one might contemplate 2.toString(),
>for example!)

>
In Smalltalk you ask the 1 object to count to 10 for a loop. It makes
sense there, it would not feel "right" in the C family...

Or anywhere else that I know of offhand.

>

>Arbitrary integer size. The only language I know having this is
>Common LISP.

>
java.math.BigIn teger, but the operations you can perform are limited.

Hm. OK, "arbitrary number size with transparency".

>

>Thread-level variable/value scoping. In Java this is done using the
>ThreadLocal class, but is not (AFAICT) supported by the language
>proper.

>
Yes, and that leads to a problem where if you forget to null a
ThreadLocal you can "leak" objects.

Ugh.

Well, unfortunately for Java it's all too easy to
leak certain objects, though the only one coming to
mind are FileInputStream , FileOutputStrea m, FileReader,
and FileWriter. Forget to close them before the variable
goes out of scope and they remain open forever, as far as
I can tell.

(Maybe that'll be fixed in a subsequent rev. I don't know.)

>

>One might even contemplate function-level scoping, but that would
>only be useful if one can create new functions on the fly and modify
>these values; otherwise, they might as well be static.

>
As long as you make sure you never use a private static member
elsewhere than in that particular method, it can play the role of a
function-level method.
>

>Persistability . In Java one can implement Serializable or
>Externalizable , and generate output from an object. I've always
>considered this a bit of a weird hack but it can come in handy, and
>forms one leg of the Java EJB implementation.

>
Persistability is left as an excercise to libraries in most languages.

True, and in that library one usually has a base class.

>

>Volatile field. In Java there is a volatile keyword. I don't know
>its precise semantics but it applies to fields.

>
In Java it's generally a hint to the optimizer NOT to optimize away or
make any assumptions about access to a field.
>

>C#'s event handling emulates this concept to some extent using the
>+= operator, though I doubt they do it all that generally -- or all
>that well.

>
Well it's closer to a list of function pointers, sorry delegates; not
much more than Java's more explicit (or cumbersome if you like) event
interfaces can do.

Operator overloading has two issues: it's far more convenient to
write something like

Matrix m1, m2;

Matrix m3 = m1 * m2;

instead of

Matrix m3 = m1.multiplyBy(m 2);

or

Matrix m3 = Matrix.multiply (m1, m2);

but it's harder for the compiler and the user to parse.
So it's a tradeoff.

The main problem I have with Swing event handling is
that occasionally it's not clear when I have to tell the
listeners that I've done something to a class which manages
a bunch of listeners. Also, ideally, one would not need
to fire off the listeners in sequence -- though without
explicitly spawning subthreads that would be difficult
in Java.

The main problem with C# event handling is that I don't
know its ramifications, but I consider delegates a bit silly,
mostly because of the Java++ fiasco. That was not COOL,
Microsoft. :-)

>

>Integrated database access (and how tightly). C++ has none at all,
>though of one can use various third-party libraries. Java has some
>base-level API -- the java.sql.* and javax.sql* library.

>
Well, those are general library APIs that require native or
socket-based implementation by vendors or third parties.
>
What you talk about is better represented by "inline" SQL in the form
of SQLJ or Oracle's Pro*C and related products.

There's the issue of how to handle schema changes, as well; that's
probably why nobody wants to tightly integrate anymore. I can't really
blame 'em.

>
It boils down to how much should be in the language (syntax, compiler,
runtime) and how much should be left to libraries. E.g. he has a "no"
for garbage collection in C++, but there are libraries for that sort
of thing (relying mostly on the ability to override the new, delete
and assignment operators. Even in Java you often have a choice of
garbage collector algorithms in a runtime.

Hm; I'll have to research that. Apart from the aforementioned stream
issues and the occasional "oops I left the thing in the global
Collection" issue, though, I've not had to do much with garbage
collection, though I did write a rather poorly-performing cache.

I will definitely have to fiddle with WeakReference at some point,
though it's probably easier just to punt to a solution like
Hibernate or JBossCache (TreeCache) or even Castor/JDO.

Like I said, FOSS has a lot of stuff out there; the main problem
for me is finding it. :-)

--
#191, ewill3@earthlin k.net
Windows Vista. Because it's time to refresh your hardware. Trust us.

[fizbin@gmail.com]

Re: Duck typing alows true polymorfisim

Just a quick note in the midst of this:

The Ghost In The Machine wrote:

Dynamic type creation. I don't know if Java has this or not.
One can of course attempt bytecode synthesis -- I think that's
what BCEL uses -- but that's a bit of a hack.

Since no one has pointed this out, I should mention the oft-neglected
class java.lang.refle ct.Proxy, which allows you to create at runtime a
class that implements a given set of interfaces and a single instance
of that class. Methods are all handled in a manner similar to ruby's
method_missing - that is, a single method is passed the method (as a
Method object) and arguments (as Object[]).

Beanshell (http://www.beanshell.org/) uses this to allow dynamic,
scripted objects (created at runtime) to implement arbitrary Java
interfaces. Reportedly, this greatly simplifies swing and AWT
programming, since one can ignore methods that are specified as part of
the interface but aren't actually used through the course of the
program.