On Monday, 9 August 2021 at 18:00:23 UTC, H. S. Teoh wrote:
> I find this to be silly OO-extremism on Java's part.  Static methods of a singleton class are basically free global functions.  Why can't they just *be* global free functions?!  But nooo, that would not jive with the OO agenda, so we have to wrap that in a singleton class just to do lip service to the OO dogma and pacify the OO police.  We're eating the greasy unhealthy food of global free functions, but to pacify our OO conscience we order the diet coke of a singleton class's static methods.

Well, if you're picky, then no, static methods are not free functions in global space, but rather can be considered as methods of object representing the class of objects (x.class). They though are usually used as free functions, and people don't fuss over whether they a free or part of a class.

I think java doesn't have any notion of a global space where you can put your funcs. There is just class and that is it.

To note, I'm not defending the choices made for java by it's dev team, just stated some facts, and personal views.

Best regards,
Alexandru.

On Monday, 9 August 2021 at 21:05:05 UTC, H. S. Teoh wrote:
> On Mon, Aug 09, 2021 at 08:18:26PM +0000, Paul Backus via Digitalmars-d wrote:
>> On Monday, 9 August 2021 at 19:23:14 UTC, H. S. Teoh wrote:
>> > As Knuth once said:
>> > 
>> > 	People who are more than casually interested in computers should
>> > 	have at least some idea of what the underlying hardware is like.
>> > 	Otherwise the programs they write will be pretty weird.
>> > 	-- D. Knuth
>> > 
>> > That includes knowing the ugly realities of 2's complement arithmetic.
>> 
>> The way I remember it, 2's complement notation is a method of encoding signed integers as unsigned integers such that a CPU can use the same instructions and circuits for both signed and unsigned arithmetic.
>> 
>> So, from the hardware's point of view, unsigned arithmetic is the pure, simple version, and signed arithmetic is the ugly, complex version. :)
>
> Indeed!  If you look at the assembly level, unsigned arithmetic is the one with straightforward instructions mapping 1-to-1 with arithmetic operations, whereas signed arithmetic is the one that involves carry bits and other such additional complications.

The carry bit is for unsigned arithmetic, it's the overflow flag that is for signed arithmetic. On a 32 bit system carry indicates that bit 31 has overflowed into bit 32, and overflow indicates bit 30 has overflowed into bit 31.

They are mainly for multiword arithmetic.

And whats probably not obvious is that you need unsigned arithmetic to do multiword signed arithmetic, you only use signed arithmetic for the top most word.

On Monday, 9 August 2021 at 22:01:33 UTC, Adam D Ruppe wrote:
> On Monday, 9 August 2021 at 21:05:05 UTC, H. S. Teoh wrote:
>> Indeed!  If you look at the assembly level, unsigned arithmetic is the one with straightforward instructions mapping 1-to-1 with arithmetic operations, whereas signed arithmetic is the one that involves carry bits and other such additional complications.
>
> They're literally identical for most operations; you can use the very same instructions and the only difference is how you interpret the data. In x86 they set both carry and overflow flags so you can decide which one you care about.

Since there's only ADD,SUB,MUL(IMUL),DIV(IDIV), it's about 50/50. Half the ops have only unsigned versions, half have signed and unsigned.

IIRC the overflow flag is actually just for catching the error, not for actual arithmetic, since if you're doing signed multiword arithmetic you only use a signed word at the top.

That's why there's ADC, SBB, but no equivalents for the overflow flag.

On Monday, 9 August 2021 at 22:57:22 UTC, claptrap wrote:
> Since there's only ADD,SUB,MUL(IMUL),DIV(IDIV), it's about 50/50.

Well, mul is semi-agnostic. It only matters if you look at the high word (which is frequently discarded anyway) and I believe imul works either way. And there's also sar vs shr which are slightly different, while sal and shl are identical.

> IIRC the overflow flag is actually just for catching the error, not for actual arithmetic, since if you're doing signed multiword arithmetic you only use a signed word at the top.

aye.

On Mon, Aug 09, 2021 at 10:32:01PM +0000, Alexandru Ermicioi via Digitalmars-d wrote:
> On Monday, 9 August 2021 at 18:00:23 UTC, H. S. Teoh wrote:
> > I find this to be silly OO-extremism on Java's part.  Static methods of a singleton class are basically free global functions.  Why can't they just *be* global free functions?!  But nooo, that would not jive with the OO agenda, so we have to wrap that in a singleton class just to do lip service to the OO dogma and pacify the OO police.  We're eating the greasy unhealthy food of global free functions, but to pacify our OO conscience we order the diet coke of a singleton class's static methods.
> 
> Well, if you're picky, then no, static methods are not free functions in global space, but rather can be considered as methods of object representing the class of objects (x.class). They though are usually used as free functions, and people don't fuss over whether they a free or part of a class.

Frankly, that's just calling a duck an aquatic chicken with webbed feet. The class is a singleton (which kinda defeats the whole point of a *class* -- at that point it might as well be just a namespace, as far as effective semantics are), and the static method does not even take a reference to said singleton class, it's completely standalone and independent (aside from the FQN).  It basically behaves like a global free function -- and is in fact the exact idiom Java uses when interfacing with C functions.  The equivalence is practically 1-to-1.

It quacks like a duck and waddles like a duck -- it's a duck.  Calling it an aquatic class method with webbed feet is really only good for doing lip service to OO dogma. For all practical purposes, it's a free function.


> I think java doesn't have any notion of a global space where you can put your funcs. There is just class and that is it.

Yes, and this is why such a non-OO hack was introduced in the first place.  Since anything existing outside a class is taboo in OO dogma, in order to rationalize away the non-OO-ness of a global free function we wrap it in the robes of a class and crown it as a method of that class. But the class is a singleton (and holds no state) and the method is static (does not depend on the class instance at all), which makes it painfully obvious that the entire intent is to rephrase "global free function" in terms that are less offensive to OO dogma.

But regardless, this shoe-horning doesn't change the fact that it essentially, for all practical purposes, behaves like a global free function.


> To note, I'm not defending the choices made for java by it's dev team, just stated some facts, and personal views.
[...]

No offense taken.  I just find the OO extremism of Java to be laughable, that's all.  Why not just admit that OO isn't the be-all and end-all of programming, and call free global functions what they are.

This is why D's multi-paradigm approach makes so much more sense: sometimes one paradigm doesn't fit the problem, why not acknowledge it and allow a different paradigm to step in.  Not every problem is a nail to which the OO hammer must be brought to bear.


T

-- 
Talk is cheap. Whining is actually free. -- Lars Wirzenius

On Mon, Aug 09, 2021 at 10:49:13PM +0000, claptrap via Digitalmars-d wrote: [...]
> And whats probably not obvious is that you need unsigned arithmetic to do multiword signed arithmetic, you only use signed arithmetic for the top most word.

Exactly!! This is why unsigned arithmetic is more basic and fundamental than signed arithmetic.  The latter is built from the former, not the former from the latter.


T

-- 
"You know, maybe we don't *need* enemies." "Yeah, best friends are about all I can take." -- Calvin & Hobbes

On Monday, 9 August 2021 at 23:09:30 UTC, H. S. Teoh wrote:
> ...
> No offense taken.  I just find the OO extremism of Java to be laughable, that's all.  Why not just admit that OO isn't the be-all and end-all of programming, and call free global functions what they are.
>
> This is why D's multi-paradigm approach makes so much more sense: sometimes one paradigm doesn't fit the problem, why not acknowledge it and allow a different paradigm to step in.  Not every problem is a nail to which the OO hammer must be brought to bear.
>
>
> T

I love how people love to hate Java, yet have no words of hate against OOP in Smalltalk, SELF, Eiffel, Sather, C#, VB, Python (check methods from typeof(func)), Dart.

How has D's multiparadigm helped to have a better marketshare than some of those extremist OOP languages?