Re: When did logical instructions appear?

[Tom Marchant]

On Mon, 20 Jun 2022 21:53:27 +1000, Robin Vowels  wrote:

>Your belligerent attitude and insulting remarks are
>tiresome.

PKB

Re: When did logical instructions appear?

[Robin Vowels]

On 2022-06-20 20:57, Seymour J Metz wrote:

Wikipedia is not a source?


You are carrying on like a peevish schoolboy.
Had I quoted a source, I would have given the link.


But your must ludicrous claim is that the fields controlling the
number of data added are not relevant.


You are just being pathetic.  I made no such claim.
In any case, it is sufficient to quote the number of words
involved in the transfer, which I did.


The effect of 11 - 25 depends
very much on those fields. I'm done here: I'm not going to spend any
more time


Good Riddance. Your belligerent attitude and insulting remarks are 
tiresome.



trying to cure your willful ignorance.


You are the ignorant one here.



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Sunday, June 19, 2022 3:44 PM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 2022-06-20 04:25, Seymour J Metz wrote:

I see that you're citing sources that you haven't read;


Now you are being absurd.
I cited no sources.  I mentioned three computers.


what a surprise.



[[Pilot ACE]] does not mention array instructions, but does
note that the hardware only did fixed point and they had to write
software to do it.


Rubbish! The hardware did exactly what I said, namely, I gave
two instructions, one to add 32 values to the accumulator
and another to subtract 32 values from the accumulator.


Neither that article nor you mentioned the "Timing
Number",


It wasn't relevant to the examples.


nor did you seem aware of the requisite values of C, W and T.


I am very aware of those and all the other components of the
Pilot ACE and DEUCE instructions.


What that entire instruction gives you is a complicated form of the
REPEATE instruction found on some later machines,


Obviously you have learned nothing.  You write nonsense.

A Pilot ACE and DEUCE instruction specifying a transfer of from
2 to 32 numbers is not a "repeat" instruction. The instruction
is not re-executed for each subsequent word.  The instruction
is not re-entered into Control.

Executing such an instruction causes the hardware to continue the
transfer for a specified number of minor cycles.  The number
of minor cycles is the difference between the wait and timing numbers,
plus 1.
The transfer commences when the wait number counts down to zero, and
terminates
when the timing number counts down to zero.

For the record, there are some 32 × 29 instructions (i.e. 928)
instructions
that can operate on arrays.  I gave examples of only two of them.


not "an instruction
set where its instructions are designed to operate efficiently and
effectively on large one-dimensional arrays of data called vectors".


Oh?  A group of 32 numbers is not a vector?
Go back to school.

The instructions on Pilot ACE and DEUCE were designed to operate
efficiently and effectively on arrays.  They could be vectors
and they could be matrices.

And for the record, at the time, Pilot ACE was the fastest machine
in the world.  Addition time was 32 + 32n microseconds (n = number of
words).
Not efficient?



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Saturday, June 18, 2022 11:05 PM
Subject: Re: When did logical instructions appear?

From: "Seymour J Metz" 
To: 
Sent: Saturday, June 18, 2022 7:50 AM



That's not enough to make it an array machine, any more than
Table lookup made the 650 an array machine.


You still don't know what you are talking about.

I suggest you read up on array processors (maybe
take a look at wiki) to inform yourself what an array processor does.

Every instruction* on Pilot ACE and DEUCE is capable of
operating on two or more values.

The examples that I gave were just two, each operating on an array of
32 values,
adding / subtracting to / from the accumulator.

_
* except for about a dozen instructions initiating I/O operations,
or changing the state of the computer.

Re: When did logical instructions appear?

[Seymour J Metz]

Wikipedia is not a source?

But your must ludicrous claim is that the fields controlling the number of data 
added are not relevant. The effect of 11 - 25 depends very much on those 
fields. I'm done here: I'm not going to spend any more time trying to cure your 
willful ignorance.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Robin Vowels [robi...@dodo.com.au]
Sent: Sunday, June 19, 2022 3:44 PM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 2022-06-20 04:25, Seymour J Metz wrote:
> I see that you're citing sources that you haven't read;

Now you are being absurd.
I cited no sources.  I mentioned three computers.

> what a surprise.

> [[Pilot ACE]] does not mention array instructions, but does
> note that the hardware only did fixed point and they had to write
> software to do it.

Rubbish! The hardware did exactly what I said, namely, I gave
two instructions, one to add 32 values to the accumulator
and another to subtract 32 values from the accumulator.

> Neither that article nor you mentioned the "Timing
> Number",

It wasn't relevant to the examples.

> nor did you seem aware of the requisite values of C, W and T.

I am very aware of those and all the other components of the
Pilot ACE and DEUCE instructions.

> What that entire instruction gives you is a complicated form of the
> REPEATE instruction found on some later machines,

Obviously you have learned nothing.  You write nonsense.

A Pilot ACE and DEUCE instruction specifying a transfer of from
2 to 32 numbers is not a "repeat" instruction. The instruction
is not re-executed for each subsequent word.  The instruction
is not re-entered into Control.

Executing such an instruction causes the hardware to continue the
transfer for a specified number of minor cycles.  The number
of minor cycles is the difference between the wait and timing numbers,
plus 1.
The transfer commences when the wait number counts down to zero, and
terminates
when the timing number counts down to zero.

For the record, there are some 32 × 29 instructions (i.e. 928)
instructions
that can operate on arrays.  I gave examples of only two of them.

> not "an instruction
> set where its instructions are designed to operate efficiently and
> effectively on large one-dimensional arrays of data called vectors".

Oh?  A group of 32 numbers is not a vector?
Go back to school.

The instructions on Pilot ACE and DEUCE were designed to operate
efficiently and effectively on arrays.  They could be vectors
and they could be matrices.

And for the record, at the time, Pilot ACE was the fastest machine
in the world.  Addition time was 32 + 32n microseconds (n = number of
words).
Not efficient?

> 
> From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
> on behalf of Robin Vowels [robi...@dodo.com.au]
> Sent: Saturday, June 18, 2022 11:05 PM
> Subject: Re: When did logical instructions appear?
>
> From: "Seymour J Metz" 
> To: 
> Sent: Saturday, June 18, 2022 7:50 AM
>
>
>> That's not enough to make it an array machine, any more than
>> Table lookup made the 650 an array machine.
>
> You still don't know what you are talking about.
>
> I suggest you read up on array processors (maybe
> take a look at wiki) to inform yourself what an array processor does.
>
> Every instruction* on Pilot ACE and DEUCE is capable of
> operating on two or more values.
>
> The examples that I gave were just two, each operating on an array of
> 32 values,
> adding / subtracting to / from the accumulator.
>
> _
> * except for about a dozen instructions initiating I/O operations,
> or changing the state of the computer.

Re: When did logical instructions appear?

[Robin Vowels]

On 2022-06-20 04:25, Seymour J Metz wrote:

I see that you're citing sources that you haven't read;


Now you are being absurd.
I cited no sources.  I mentioned three computers.


what a surprise.



[[Pilot ACE]] does not mention array instructions, but does
note that the hardware only did fixed point and they had to write
software to do it.


Rubbish! The hardware did exactly what I said, namely, I gave
two instructions, one to add 32 values to the accumulator
and another to subtract 32 values from the accumulator.


Neither that article nor you mentioned the "Timing
Number",


It wasn't relevant to the examples.


nor did you seem aware of the requisite values of C, W and T.


I am very aware of those and all the other components of the
Pilot ACE and DEUCE instructions.


What that entire instruction gives you is a complicated form of the
REPEATE instruction found on some later machines,


Obviously you have learned nothing.  You write nonsense.

A Pilot ACE and DEUCE instruction specifying a transfer of from
2 to 32 numbers is not a "repeat" instruction. The instruction
is not re-executed for each subsequent word.  The instruction
is not re-entered into Control.

Executing such an instruction causes the hardware to continue the
transfer for a specified number of minor cycles.  The number
of minor cycles is the difference between the wait and timing numbers, 
plus 1.
The transfer commences when the wait number counts down to zero, and 
terminates

when the timing number counts down to zero.

For the record, there are some 32 × 29 instructions (i.e. 928) 
instructions

that can operate on arrays.  I gave examples of only two of them.


not "an instruction
set where its instructions are designed to operate efficiently and
effectively on large one-dimensional arrays of data called vectors".


Oh?  A group of 32 numbers is not a vector?
Go back to school.

The instructions on Pilot ACE and DEUCE were designed to operate
efficiently and effectively on arrays.  They could be vectors
and they could be matrices.

And for the record, at the time, Pilot ACE was the fastest machine
in the world.  Addition time was 32 + 32n microseconds (n = number of 
words).

Not efficient?



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Saturday, June 18, 2022 11:05 PM
Subject: Re: When did logical instructions appear?

From: "Seymour J Metz" 
To: 
Sent: Saturday, June 18, 2022 7:50 AM



That's not enough to make it an array machine, any more than
Table lookup made the 650 an array machine.


You still don't know what you are talking about.

I suggest you read up on array processors (maybe
take a look at wiki) to inform yourself what an array processor does.

Every instruction* on Pilot ACE and DEUCE is capable of
operating on two or more values.

The examples that I gave were just two, each operating on an array of 
32 values,

adding / subtracting to / from the accumulator.

_
* except for about a dozen instructions initiating I/O operations,
or changing the state of the computer.

Re: When did logical instructions appear?

[Seymour J Metz]

I see that you're citing sources that you haven't read; what a surprise. 
[[Pilot ACE]] does not mention array instructions, but does note that the 
hardware only did fixed point and they had to write software to do it. Neither 
that article nor you mentioned the "Timing Number", nor did you seem aware of 
the requisite values of C, W and T.

What that entire instruction gives you is a complicated form of the REPEATE 
instruction found on some later machines, not "an instruction set where its 
instructions are designed to operate efficiently and effectively on large 
one-dimensional arrays of data called vectors".


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Robin Vowels [robi...@dodo.com.au]
Sent: Saturday, June 18, 2022 11:05 PM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

From: "Seymour J Metz" 
To: 
Sent: Saturday, June 18, 2022 7:50 AM


> That's not enough to make it an array machine, any more than Table lookup 
> made the 650 an array
> machine.

You still don't know what you are talking about.

I suggest you read up on array processors (maybe
take a look at wiki) to inform yourself what an array processor does.

Every instruction* on Pilot ACE and DEUCE is capable of
operating on two or more values.

The examples that I gave were just two, each operating on an array of 32 values,
adding / subtracting to / from the accumulator.

_
* except for about a dozen instructions initiating I/O operations,
or changing the state of the computer.

Re: When did logical instructions appear?

[Robin Vowels]

From: "Seymour J Metz" 
To: 
Sent: Saturday, June 18, 2022 7:50 AM


That's not enough to make it an array machine, any more than Table lookup made the 650 an array 
machine.


You still don't know what you are talking about.

I suggest you read up on array processors (maybe
take a look at wiki) to inform yourself what an array processor does.

Every instruction* on Pilot ACE and DEUCE is capable of
operating on two or more values.

The examples that I gave were just two, each operating on an array of 32 values,
adding / subtracting to / from the accumulator.

_
* except for about a dozen instructions initiating I/O operations,
or changing the state of the computer.



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf of Robin Vowels 
[robi...@dodo.com.au]

Sent: Friday, June 17, 2022 10:42 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 2022-06-17 23:31, Seymour J Metz wrote:

Whoosh! How is a statement about 2's complement machines relevant to a
statement about 1s' complement machines?


You mean that you don't know?


Your statements about array machines were utter nonsense, not facts.
Are you confusing array machines with serial machines?

Either you were using words whose meanings you don't know, e.g.,
array, or you were making ludicrous assumptions. Whatever you may have
meant to write, The Pilot ACE, DEUCE, and ACE were *NOT* array
machines.


Oh?  The instruction 11-25 executed for 1024 microseconds added
the 32 words in Delay Line 11 to the content of the accumulator.
Similarly, the instruction 10-26 for 1024 microseconds subtracted the
32 words in Delay Line 10 from the contents of the accumulator.



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 5:57 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 2022-06-17 19:02, Seymour J Metz wrote:

I'm not aware of any serial 1s' complement or 2's complement machines.


In this forum, just a few letters ago, I stated that Pilot ACE,
DEUCE, and ACE were serial machines that held negative values in
twos complement form.


You've made claims;


They weren't "claims".  They are statements of facts.


that doesn't mean that they are true. There is
nothing that precludes any representation in an array machine.


Don't talk nonsense.
These are statements of facts from my knowledge of how
those serial machines worked.


You are
begging the questions by the assumptions that you are making.


I made no assumptions.
On the other hand, your assertions are nonsense.



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 4:54 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU

On 2022-06-17 18:04, Seymour J Metz wrote:

FSVO serial. The early electronic machines that I'm aware of were
parallel.

FWIW, there were papers claiming that 1s' complement was simpler.


Not in a serial machine.
What's more, I've already pointed out that in an array machine,
ones complement was impossible because you only got one look
at the operands and the result.  The result had to be stored
in the same cycle as the operands were available, because the
next cycle the sum or difference of the next operands was required
to be performed. In a serial machine, the sum of a pair of
corresponding bits produces at the same moment the sum bit.


I
believe that the tradeoffs vary depending on the technology used. 



---
This email has been checked for viruses by Avast antivirus software.
https://www.avast.com/antivirus

Re: When did logical instructions appear?

[Seymour J Metz]

That's not enough to make it an array machine, any more than Table lookup made 
the 650 an array machine.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 10:42 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 2022-06-17 23:31, Seymour J Metz wrote:
> Whoosh! How is a statement about 2's complement machines relevant to a
> statement about 1s' complement machines?

You mean that you don't know?

> Your statements about array machines were utter nonsense, not facts.
> Are you confusing array machines with serial machines?
>
> Either you were using words whose meanings you don't know, e.g.,
> array, or you were making ludicrous assumptions. Whatever you may have
> meant to write, The Pilot ACE, DEUCE, and ACE were *NOT* array
> machines.

Oh?  The instruction 11-25 executed for 1024 microseconds added
the 32 words in Delay Line 11 to the content of the accumulator.
Similarly, the instruction 10-26 for 1024 microseconds subtracted the
32 words in Delay Line 10 from the contents of the accumulator.

> 
> From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
> on behalf of Robin Vowels [robi...@dodo.com.au]
> Sent: Friday, June 17, 2022 5:57 AM
> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
> Subject: Re: When did logical instructions appear?
>
> On 2022-06-17 19:02, Seymour J Metz wrote:
>> I'm not aware of any serial 1s' complement or 2's complement machines.
>
> In this forum, just a few letters ago, I stated that Pilot ACE,
> DEUCE, and ACE were serial machines that held negative values in
> twos complement form.
>
>> You've made claims;
>
> They weren't "claims".  They are statements of facts.
>
>> that doesn't mean that they are true. There is
>> nothing that precludes any representation in an array machine.
>
> Don't talk nonsense.
> These are statements of facts from my knowledge of how
> those serial machines worked.
>
>> You are
>> begging the questions by the assumptions that you are making.
>
> I made no assumptions.
> On the other hand, your assertions are nonsense.
>
>> 
>> From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
>> on behalf of Robin Vowels [robi...@dodo.com.au]
>> Sent: Friday, June 17, 2022 4:54 AM
>> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
>>
>> On 2022-06-17 18:04, Seymour J Metz wrote:
>>> FSVO serial. The early electronic machines that I'm aware of were
>>> parallel.
>>>
>>> FWIW, there were papers claiming that 1s' complement was simpler.
>>
>> Not in a serial machine.
>> What's more, I've already pointed out that in an array machine,
>> ones complement was impossible because you only got one look
>> at the operands and the result.  The result had to be stored
>> in the same cycle as the operands were available, because the
>> next cycle the sum or difference of the next operands was required
>> to be performed. In a serial machine, the sum of a pair of
>> corresponding bits produces at the same moment the sum bit.
>>
>>> I
>>> believe that the tradeoffs vary depending on the technology used.

Re: When did logical instructions appear?

[Seymour J Metz]

That would depend on the word size; depending on the machine, that was 
generally 12, 18, 24, 30, 36, 48 or 60, with a few other less common sizes. So 
HW would have been 6, 9, 12, 15, 18, 24 or 30, had they used the term.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Phil Smith III [li...@akphs.com]
Sent: Friday, June 17, 2022 1:00 PM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

> I suspect that it goes back farther. There was no concept of halfword at
the time;
> it was all 36-bit words.



Oooh, I like the idea of halfwords in that context-19 bits! Just think, we'd
all know the numbers 524,288 and 262,144 like we know 32K and 64K...

Re: When did logical instructions appear?

[Seymour J Metz]

The IBM 7030 (Stretch) Connect instructions also supported all 16 oiperations. 
There are probably others.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Paul Gilmartin [0014e0e4a59b-dmarc-requ...@listserv.uga.edu]
Sent: Friday, June 17, 2022 2:03 PM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 6/17/22 11:00:30, Phil Smith III wrote:
>> I suspect that it goes back farther. There was no concept of halfword at
> the time;
>> it was all 36-bit words.
> Oooh, I like the idea of halfwords in that context-19 bits! Just think, we'd
> all know the numbers 524,288 and 262,144 like we know 32K and 64K...
>
>

Oooh!*DECsystem-10! It used the same instruction to negate floating- and
fixed-point values (36-bit twos complement). And all 16 dyadic Boolean
operations (a complete **Karnaugh map embedded in 4 bits of the op code with a 
mnemonic for each)**, most of which werre useless. *
--
gil

Re: When did logical instructions appear?

[Phil Smith III]

Charles added:
>Or maybe rather than halfword instructions, the architecture needs 53%word
>instructions.

 

You're being kind--clearly I need 53% of a brain!

Re: When did logical instructions appear?

[Charles Mills]

Or maybe rather than halfword instructions, the architecture needs 53%word
instructions. 

Charles


-Original Message-
From: IBM Mainframe Assembler List [mailto:ASSEMBLER-LIST@LISTSERV.UGA.EDU]
On Behalf Of Phil Smith III
Sent: Friday, June 17, 2022 10:38 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

Charles Mills asked:

>In what base is 19 half of 36?

 

In the "It's Friday" base? OK, 262,144 and 131,072.

 

/me tries to slap forehead, misses because head is shaking too fast. It's
been a long week.

Re: When did logical instructions appear?

[Paul Gilmartin]

On 6/17/22 11:00:30, Phil Smith III wrote:

I suspect that it goes back farther. There was no concept of halfword at

the time;

it was all 36-bit words.

Oooh, I like the idea of halfwords in that context-19 bits! Just think, we'd
all know the numbers 524,288 and 262,144 like we know 32K and 64K...

  


Oooh!*DECsystem-10! It used the same instruction to negate floating- and 
fixed-point values (36-bit twos complement). And all 16 dyadic Boolean 
operations (a complete **Karnaugh map embedded in 4 bits of the op code with a mnemonic for each)**, most of which werre useless. *

--
gil

Re: When did logical instructions appear?

[Phil Smith III]

Charles Mills asked:

>In what base is 19 half of 36?

 

In the "It's Friday" base? OK, 262,144 and 131,072.

 

/me tries to slap forehead, misses because head is shaking too fast. It's
been a long week.

Re: When did logical instructions appear?

[Charles Mills]

In what base is 19 half of 36?

Charles


-Original Message-
From: IBM Mainframe Assembler List [mailto:ASSEMBLER-LIST@LISTSERV.UGA.EDU]
On Behalf Of Phil Smith III
Sent: Friday, June 17, 2022 10:01 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

> I suspect that it goes back farther. There was no concept of halfword at
the time;
> it was all 36-bit words.

 

Oooh, I like the idea of halfwords in that context-19 bits! Just think, we'd
all know the numbers 524,288 and 262,144 like we know 32K and 64K...

 

Re: When did logical instructions appear?

[Phil Smith III]

> I suspect that it goes back farther. There was no concept of halfword at
the time;
> it was all 36-bit words.

 

Oooh, I like the idea of halfwords in that context-19 bits! Just think, we'd
all know the numbers 524,288 and 262,144 like we know 32K and 64K...

 

Re: When did logical instructions appear?

[Robin Vowels]

On 2022-06-17 23:31, Seymour J Metz wrote:

Whoosh! How is a statement about 2's complement machines relevant to a
statement about 1s' complement machines?


You mean that you don't know?


Your statements about array machines were utter nonsense, not facts.
Are you confusing array machines with serial machines?

Either you were using words whose meanings you don't know, e.g.,
array, or you were making ludicrous assumptions. Whatever you may have
meant to write, The Pilot ACE, DEUCE, and ACE were *NOT* array
machines.


Oh?  The instruction 11-25 executed for 1024 microseconds added
the 32 words in Delay Line 11 to the content of the accumulator.
Similarly, the instruction 10-26 for 1024 microseconds subtracted the
32 words in Delay Line 10 from the contents of the accumulator.



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 5:57 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 2022-06-17 19:02, Seymour J Metz wrote:

I'm not aware of any serial 1s' complement or 2's complement machines.


In this forum, just a few letters ago, I stated that Pilot ACE,
DEUCE, and ACE were serial machines that held negative values in
twos complement form.


You've made claims;


They weren't "claims".  They are statements of facts.


that doesn't mean that they are true. There is
nothing that precludes any representation in an array machine.


Don't talk nonsense.
These are statements of facts from my knowledge of how
those serial machines worked.


You are
begging the questions by the assumptions that you are making.


I made no assumptions.
On the other hand, your assertions are nonsense.



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 4:54 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU

On 2022-06-17 18:04, Seymour J Metz wrote:

FSVO serial. The early electronic machines that I'm aware of were
parallel.

FWIW, there were papers claiming that 1s' complement was simpler.


Not in a serial machine.
What's more, I've already pointed out that in an array machine,
ones complement was impossible because you only got one look
at the operands and the result.  The result had to be stored
in the same cycle as the operands were available, because the
next cycle the sum or difference of the next operands was required
to be performed. In a serial machine, the sum of a pair of
corresponding bits produces at the same moment the sum bit.


I
believe that the tradeoffs vary depending on the technology used.

Re: When did logical instructions appear?

[Seymour J Metz]

Whoosh! How is a statement about 2's complement machines relevant to a 
statement about 1s' complement machines?

Your statements about array machines were utter nonsense, not facts. Are you 
confusing array machines with serial machines?

Either you were using words whose meanings you don't know, e.g., array, or you 
were making ludicrous assumptions. Whatever you may have meant to write, The 
Pilot ACE, DEUCE, and ACE were *NOT* array machines.

--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 5:57 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 2022-06-17 19:02, Seymour J Metz wrote:
> I'm not aware of any serial 1s' complement or 2's complement machines.

In this forum, just a few letters ago, I stated that Pilot ACE,
DEUCE, and ACE were serial machines that held negative values in
twos complement form.

> You've made claims;

They weren't "claims".  They are statements of facts.

> that doesn't mean that they are true. There is
> nothing that precludes any representation in an array machine.

Don't talk nonsense.
These are statements of facts from my knowledge of how
those serial machines worked.

> You are
> begging the questions by the assumptions that you are making.

I made no assumptions.
On the other hand, your assertions are nonsense.

> 
> From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
> on behalf of Robin Vowels [robi...@dodo.com.au]
> Sent: Friday, June 17, 2022 4:54 AM
> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
>
> On 2022-06-17 18:04, Seymour J Metz wrote:
>> FSVO serial. The early electronic machines that I'm aware of were
>> parallel.
>>
>> FWIW, there were papers claiming that 1s' complement was simpler.
>
> Not in a serial machine.
> What's more, I've already pointed out that in an array machine,
> ones complement was impossible because you only got one look
> at the operands and the result.  The result had to be stored
> in the same cycle as the operands were available, because the
> next cycle the sum or difference of the next operands was required
> to be performed. In a serial machine, the sum of a pair of
> corresponding bits produces at the same moment the sum bit.
>
>> I
>> believe that the tradeoffs vary depending on the technology used.
>
>>
>> 
>> From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
>> on behalf of Robin Vowels [robi...@dodo.com.au]
>> Sent: Friday, June 17, 2022 2:40 AM
>> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
>> Subject: Re: When did logical instructions appear?
>>
>> - Original Message -
>> From: "Paul Gilmartin"
>> <0014e0e4a59b-dmarc-requ...@listserv.uga.edu>
>> To: 
>> Sent: Friday, June 17, 2022 7:20 AM
>>
>>
>>> On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:
>>>>
>>>> Computers have had instructions for signed and unsigned binary
>>>> since at least 1951. When negative values are expressed using
>>>> twos complement notation, ordinary addition will give the same
>>>> result whether the operation is signed or unsigned.
>>>>
>>> It puzzles me that some of the oldest computers employed sign-
>>> magnitude notation when 2's (1's, 10's) complement would have
>>> needed fewer gates and fewer clock cycles.
>>
>> For a serial machine (and most of them were in the early days),
>> twos complement was the simplest.  It needed only one cycle
>> for add and subtract.  Even subtract (complement and add one)
>> was done in a single cycle, "on the fly".  It was unnecessary to
>> add the one; complement commencing after the first non-zero bit.
>>
>> Ones complement was a PITA, because a carry out of the high end
>> required a 1 to be added in the next cycle.  This was no good at
>> all for array machines such as Pilot ACE, DEUCE, and ACE,
>> because the word just summed would not have been around
>> to add the final "1" produced by the carry out -- the arithmetic
>> unit already working on summing (or subtracting) the next pair
>> of words.
>>
>>> Perhaps an accommodation to the engineers' habits.

Re: When did logical instructions appear?

[Paul Gilmartin]

On 6/17/22 02:54:31, Robin Vowels wrote:

On 2022-06-17 18:04, Seymour J Metz wrote:
FSVO serial. The early electronic machines that I'm aware of were 
parallel.


FWIW, there were papers claiming that 1s' complement was simpler.


Not in a serial machine.


Was serial technology the motivation for little-endian representation, which

many mainframe programmers regard as counterintuitive?


--
gil

Re: When did logical instructions appear?

[Robin Vowels]

On 2022-06-17 19:02, Seymour J Metz wrote:

I'm not aware of any serial 1s' complement or 2's complement machines.


In this forum, just a few letters ago, I stated that Pilot ACE,
DEUCE, and ACE were serial machines that held negative values in
twos complement form.


You've made claims;


They weren't "claims".  They are statements of facts.


that doesn't mean that they are true. There is
nothing that precludes any representation in an array machine.


Don't talk nonsense.
These are statements of facts from my knowledge of how
those serial machines worked.


You are
begging the questions by the assumptions that you are making.


I made no assumptions.
On the other hand, your assertions are nonsense.



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 4:54 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU

On 2022-06-17 18:04, Seymour J Metz wrote:

FSVO serial. The early electronic machines that I'm aware of were
parallel.

FWIW, there were papers claiming that 1s' complement was simpler.


Not in a serial machine.
What's more, I've already pointed out that in an array machine,
ones complement was impossible because you only got one look
at the operands and the result.  The result had to be stored
in the same cycle as the operands were available, because the
next cycle the sum or difference of the next operands was required
to be performed. In a serial machine, the sum of a pair of
corresponding bits produces at the same moment the sum bit.


I
believe that the tradeoffs vary depending on the technology used.





From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 2:40 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

- Original Message -
From: "Paul Gilmartin"
<0014e0e4a59b-dmarc-requ...@listserv.uga.edu>
To: 
Sent: Friday, June 17, 2022 7:20 AM



On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:


Computers have had instructions for signed and unsigned binary
since at least 1951. When negative values are expressed using
twos complement notation, ordinary addition will give the same
result whether the operation is signed or unsigned.


It puzzles me that some of the oldest computers employed sign-
magnitude notation when 2's (1's, 10's) complement would have
needed fewer gates and fewer clock cycles.


For a serial machine (and most of them were in the early days),
twos complement was the simplest.  It needed only one cycle
for add and subtract.  Even subtract (complement and add one)
was done in a single cycle, "on the fly".  It was unnecessary to
add the one; complement commencing after the first non-zero bit.

Ones complement was a PITA, because a carry out of the high end
required a 1 to be added in the next cycle.  This was no good at
all for array machines such as Pilot ACE, DEUCE, and ACE,
because the word just summed would not have been around
to add the final "1" produced by the carry out -- the arithmetic
unit already working on summing (or subtracting) the next pair
of words.


Perhaps an accommodation to the engineers' habits.

Re: When did logical instructions appear?

[Seymour J Metz]

ENIAC was decimal; I don't know how digits were encoded.

The 701 and 702 were parallel; each bank had one Williams tube per bit.

The 1951 ERA 1101 was parallel 1s' complement with drum memory.

The 1951-1952 ILLIAC 1 and ORDVAC were parallel 2's complement

Were there any 1940s serial machines actually shipped to remote sites?


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of dave.g4...@gmail.com [dave.g4...@gmail.com]
Sent: Friday, June 17, 2022 4:40 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

Seymour, (Hope that's ok)

Many early machines were serial. The Manchester SSEM and it successors the
Manchester MK1 and Ferrante MK1* were all serial, as was the Ferranti
Pegasus.
The machine at Cambridge(UK), EDSAC was also serial. Not sure about ENIAC
but wasn't that a decimal machine as well?. EDVAC was also serial.

For example, the Manchester Baby was a 32 bit machine with three Williams
tubes,

Main Store (32 x 32)
Accumulator (1 x 32)
Control Store (2 x 32)

To build that as a parallel machine would have needed 96 Williams tubes, I
believe that even the IBM 701 only had 72.
.. so I think if you are building a machine with storage that is inherently
serial at some level, so Williams Tubes, Delay Lines or even a drum it makes
sense to build a serial machine.
Once you start using core storage and transistors the mathematics change and
parallel becomes much more attractive...

Dave




> -Original Message-
> From: IBM Mainframe Assembler List 
> On Behalf Of Seymour J Metz
> Sent: 17 June 2022 09:05
> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
> Subject: Re: When did logical instructions appear?
>
> FSVO serial. The early electronic machines that I'm aware of were
parallel.
>
> FWIW, there were papers claiming that 1s' complement was simpler. I
believe
> that the tradeoffs vary depending on the technology used.
>
>
> --
> Shmuel (Seymour J.) Metz
> http://mason.gmu.edu/~smetz3
>
> 
> From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
> on behalf of Robin Vowels [robi...@dodo.com.au]
> Sent: Friday, June 17, 2022 2:40 AM
> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
> Subject: Re: When did logical instructions appear?
>
> - Original Message -
> From: "Paul Gilmartin" <0014e0e4a59b-dmarc-
> requ...@listserv.uga.edu>
> To: 
> Sent: Friday, June 17, 2022 7:20 AM
> Subject: Re: When did logical instructions appear?
>
>
> > On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:
> >>
> >> Computers have had instructions for signed and unsigned binary since
> >> at least 1951. When negative values are expressed using twos
> >> complement notation, ordinary addition will give the same result
> >> whether the operation is signed or unsigned.
> >>
> > It puzzles me that some of the oldest computers employed sign-
> > magnitude notation when 2's (1's, 10's) complement would have needed
> > fewer gates and fewer clock cycles.
>
> For a serial machine (and most of them were in the early days), twos
> complement was the simplest.  It needed only one cycle for add and
subtract.
> Even subtract (complement and add one) was done in a single cycle, "on the
fly".
> It was unnecessary to add the one; complement commencing after the first
non-
> zero bit.
>
> Ones complement was a PITA, because a carry out of the high end required a
1
> to be added in the next cycle.  This was no good at all for array machines
such as
> Pilot ACE, DEUCE, and ACE, because the word just summed would not have
been
> around to add the final "1" produced by the carry out -- the arithmetic
unit
> already working on summing (or subtracting) the next pair of words.
>
> > Perhaps an accommodation to the engineers' habits.
>
> ---
> This email has been checked for viruses by Avast antivirus software.
> https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.av%2Fdata=05%7C01%7Csmetz3%40gmu.edu%7Cb9cbc968835945d368cd08da503d0a9e%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C637910520357625294%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7Csdata=sLQjMzVnB%2FMkz8c3EX2lLma8BIKWxlWsxt2GAB2vQA4%3Dreserved=0
> ast.com%2Fantivirusdata=05%7C01%7Csmetz3%40gmu.edu%7Cf84bb17
> cd7eb400175a608da502c27ae%7C9e857255df574c47a0c00546460380cb%7C0
> %7C0%7C637910447840045536%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4
> wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C
> %7C%7Csdata=o2r1kMl7%2F4ORpMDX%2Br1beF%2F271qN32kc3tBcqz6
> H7l0%3Dreserved=0

Re: When did logical instructions appear?

[Seymour J Metz]

I'm not aware of any serial 1s' complement or 2's complement machines.

You've made claims; that doesn't mean that they are true. There is nothing that 
precludes any representation in an array machine. You are begging the questions 
by the assumptions that you are making.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 4:54 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On 2022-06-17 18:04, Seymour J Metz wrote:
> FSVO serial. The early electronic machines that I'm aware of were
> parallel.
>
> FWIW, there were papers claiming that 1s' complement was simpler.

Not in a serial machine.
What's more, I've already pointed out that in an array machine,
ones complement was impossible because you only got one look
at the operands and the result.  The result had to be stored
in the same cycle as the operands were available, because the
next cycle the sum or difference of the next operands was required
to be performed. In a serial machine, the sum of a pair of
corresponding bits produces at the same moment the sum bit.

> I
> believe that the tradeoffs vary depending on the technology used.

>
> 
> From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
> on behalf of Robin Vowels [robi...@dodo.com.au]
> Sent: Friday, June 17, 2022 2:40 AM
> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
> Subject: Re: When did logical instructions appear?
>
> - Original Message -
> From: "Paul Gilmartin"
> <0014e0e4a59b-dmarc-requ...@listserv.uga.edu>
> To: 
> Sent: Friday, June 17, 2022 7:20 AM
>
>
>> On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:
>>>
>>> Computers have had instructions for signed and unsigned binary
>>> since at least 1951. When negative values are expressed using
>>> twos complement notation, ordinary addition will give the same
>>> result whether the operation is signed or unsigned.
>>>
>> It puzzles me that some of the oldest computers employed sign-
>> magnitude notation when 2's (1's, 10's) complement would have
>> needed fewer gates and fewer clock cycles.
>
> For a serial machine (and most of them were in the early days),
> twos complement was the simplest.  It needed only one cycle
> for add and subtract.  Even subtract (complement and add one)
> was done in a single cycle, "on the fly".  It was unnecessary to
> add the one; complement commencing after the first non-zero bit.
>
> Ones complement was a PITA, because a carry out of the high end
> required a 1 to be added in the next cycle.  This was no good at
> all for array machines such as Pilot ACE, DEUCE, and ACE,
> because the word just summed would not have been around
> to add the final "1" produced by the carry out -- the arithmetic
> unit already working on summing (or subtracting) the next pair
> of words.
>
>> Perhaps an accommodation to the engineers' habits.

Re: When did logical instructions appear?

[dave . g4ugm]

> -Original Message-
> From: IBM Mainframe Assembler List 
> On Behalf Of Robin Vowels
> Sent: 17 June 2022 09:39
> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
> Subject: Re: When did logical instructions appear?
> 
> On 2022-06-17 18:20, Seymour J Metz wrote:
> > IBM was sign-magnitude in the 1950s, but CDC and UNIVAC inherited 1s'
> > complement from ERA. I'm not sure what the first 2's complement
> > machine was.
> 
> EDSAC was working in 1949.
> 
> It may not have been the first.
> 
Manchester Baby in 1948 was also 2's complement. So the first program from
RAM used 2's complement.

Dave

Re: When did logical instructions appear?

[dave . g4ugm]

Seymour, (Hope that's ok)

Many early machines were serial. The Manchester SSEM and it successors the
Manchester MK1 and Ferrante MK1* were all serial, as was the Ferranti
Pegasus.
The machine at Cambridge(UK), EDSAC was also serial. Not sure about ENIAC
but wasn't that a decimal machine as well?. EDVAC was also serial.

For example, the Manchester Baby was a 32 bit machine with three Williams
tubes,  

Main Store (32 x 32)
Accumulator (1 x 32)
Control Store (2 x 32)

To build that as a parallel machine would have needed 96 Williams tubes, I
believe that even the IBM 701 only had 72.
.. so I think if you are building a machine with storage that is inherently
serial at some level, so Williams Tubes, Delay Lines or even a drum it makes
sense to build a serial machine.
Once you start using core storage and transistors the mathematics change and
parallel becomes much more attractive...

Dave
  



> -Original Message-
> From: IBM Mainframe Assembler List 
> On Behalf Of Seymour J Metz
> Sent: 17 June 2022 09:05
> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
> Subject: Re: When did logical instructions appear?
> 
> FSVO serial. The early electronic machines that I'm aware of were
parallel.
> 
> FWIW, there were papers claiming that 1s' complement was simpler. I
believe
> that the tradeoffs vary depending on the technology used.
> 
> 
> --
> Shmuel (Seymour J.) Metz
> http://mason.gmu.edu/~smetz3
> 
> 
> From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
> on behalf of Robin Vowels [robi...@dodo.com.au]
> Sent: Friday, June 17, 2022 2:40 AM
> To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
> Subject: Re: When did logical instructions appear?
> 
> - Original Message -
> From: "Paul Gilmartin" <0014e0e4a59b-dmarc-
> requ...@listserv.uga.edu>
> To: 
> Sent: Friday, June 17, 2022 7:20 AM
> Subject: Re: When did logical instructions appear?
> 
> 
> > On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:
> >>
> >> Computers have had instructions for signed and unsigned binary since
> >> at least 1951. When negative values are expressed using twos
> >> complement notation, ordinary addition will give the same result
> >> whether the operation is signed or unsigned.
> >>
> > It puzzles me that some of the oldest computers employed sign-
> > magnitude notation when 2's (1's, 10's) complement would have needed
> > fewer gates and fewer clock cycles.
> 
> For a serial machine (and most of them were in the early days), twos
> complement was the simplest.  It needed only one cycle for add and
subtract.
> Even subtract (complement and add one) was done in a single cycle, "on the
fly".
> It was unnecessary to add the one; complement commencing after the first
non-
> zero bit.
> 
> Ones complement was a PITA, because a carry out of the high end required a
1
> to be added in the next cycle.  This was no good at all for array machines
such as
> Pilot ACE, DEUCE, and ACE, because the word just summed would not have
been
> around to add the final "1" produced by the carry out -- the arithmetic
unit
> already working on summing (or subtracting) the next pair of words.
> 
> > Perhaps an accommodation to the engineers' habits.
> 
> ---
> This email has been checked for viruses by Avast antivirus software.
> https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.av
> ast.com%2Fantivirusdata=05%7C01%7Csmetz3%40gmu.edu%7Cf84bb17
> cd7eb400175a608da502c27ae%7C9e857255df574c47a0c00546460380cb%7C0
> %7C0%7C637910447840045536%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4
> wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C
> %7C%7Csdata=o2r1kMl7%2F4ORpMDX%2Br1beF%2F271qN32kc3tBcqz6
> H7l0%3Dreserved=0

Re: When did logical instructions appear?

[Robin Vowels]

On 2022-06-17 18:20, Seymour J Metz wrote:

IBM was sign-magnitude in the 1950s, but CDC and UNIVAC inherited 1s'
complement from ERA. I'm not sure what the first 2's complement
machine was.


EDSAC was working in 1949.

It may not have been the first.



From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU]
on behalf of Paul Gilmartin
[0014e0e4a59b-dmarc-requ...@listserv.uga.edu]
Sent: Thursday, June 16, 2022 5:20 PM

On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:


Computers have had instructions for signed and unsigned binary
since at least 1951.  When negative values are expressed using
twos complement notation, ordinary addition will give the same
result whether the operation is signed or unsigned.


It puzzles me that some of the oldest computers employed sign-
magnitude notation when 2's (1's, 10's) complement would have
needed fewer gates and fewer clock cycles.

Perhaps an accommodation to the engineers' habits.

--
gil

Re: When did logical instructions appear?

[Seymour J Metz]

IBM was sign-magnitude in the 1950s, but CDC and UNIVAC inherited 1s' 
complement from ERA. I'm not sure what the first 2's complement machine was.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Paul Gilmartin [0014e0e4a59b-dmarc-requ...@listserv.uga.edu]
Sent: Thursday, June 16, 2022 5:20 PM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:
>
> Computers have had instructions for signed and unsigned binary
> since at least 1951.  When negative values are expressed using
> twos complement notation, ordinary addition will give the same
> result whether the operation is signed or unsigned.
>
It puzzles me that some of the oldest computers employed sign-
magnitude notation when 2's (1's, 10's) complement would have
needed fewer gates and fewer clock cycles.

Perhaps an accommodation to the engineers' habits.

--
gil

Re: When did logical instructions appear?

[Seymour J Metz]

FSVO serial. The early electronic machines that I'm aware of were parallel.

FWIW, there were papers claiming that 1s' complement was simpler. I believe 
that the tradeoffs vary depending on the technology used.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 2:40 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

- Original Message -
From: "Paul Gilmartin" <0014e0e4a59b-dmarc-requ...@listserv.uga.edu>
To: 
Sent: Friday, June 17, 2022 7:20 AM
Subject: Re: When did logical instructions appear?


> On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:
>>
>> Computers have had instructions for signed and unsigned binary
>> since at least 1951. When negative values are expressed using
>> twos complement notation, ordinary addition will give the same
>> result whether the operation is signed or unsigned.
>>
> It puzzles me that some of the oldest computers employed sign-
> magnitude notation when 2's (1's, 10's) complement would have
> needed fewer gates and fewer clock cycles.

For a serial machine (and most of them were in the early days),
twos complement was the simplest.  It needed only one cycle
for add and subtract.  Even subtract (complement and add one)
was done in a single cycle, "on the fly".  It was unnecessary to
add the one; complement commencing after the first non-zero bit.

Ones complement was a PITA, because a carry out of the high end
required a 1 to be added in the next cycle.  This was no good at
all for array machines such as Pilot ACE, DEUCE, and ACE,
because the word just summed would not have been around
to add the final "1" produced by the carry out -- the arithmetic
unit already working on summing (or subtracting) the next pair
of words.

> Perhaps an accommodation to the engineers' habits.

---
This email has been checked for viruses by Avast antivirus software.
https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.avast.com%2Fantivirusdata=05%7C01%7Csmetz3%40gmu.edu%7Cf84bb17cd7eb400175a608da502c27ae%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C637910447840045536%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7Csdata=o2r1kMl7%2F4ORpMDX%2Br1beF%2F271qN32kc3tBcqz6H7l0%3Dreserved=0

Re: When did logical instructions appear?

[Seymour J Metz]

FSVO already.

1951 and 1954 *ARE* of comparable antiquity.  I picked 1955 only because I knew 
that there was a 704 manual on bitsavers.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Robin Vowels [robi...@dodo.com.au]
Sent: Friday, June 17, 2022 2:46 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

From: "Seymour J Metz" 
To: 
Sent: Friday, June 17, 2022 1:07 AM

> Unsigned binary arithmetic goes back at least to the 704 in 1955.

I already said that it goes back to 1951, at least.

> I suspect that it goes back farther. There was no concept of halfword at the 
> time;
> it was all 36-bit words.

> Logical AND, OR, etc. have comparable antiquity.

Logical AND, OR, EXCLUSIVE OR, etc, were already around by 1951.

---
This email has been checked for viruses by Avast antivirus software.
https://nam11.safelinks.protection.outlook.com/?url=https%3A%2F%2Fwww.avast.com%2Fantivirusdata=05%7C01%7Csmetz3%40gmu.edu%7C0b9b180d309741a60c1208da502d0de7%7C9e857255df574c47a0c00546460380cb%7C0%7C0%7C637910451699779917%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000%7C%7C%7Csdata=0sQ0gE9RgKpptKgTc4mKKuh2KiSnaf3CAYO08oDMEMk%3Dreserved=0

Re: When did logical instructions appear?

[Abe Kornelis]

Michael, all,

in addition to all the replies already provided, I would like to point
you to a page I created:
https://bixoft.nl/english/opcodes.htm

Kind regards & happy programming!
Abe
===


Op 16/06/2022 om 16:36 schreef Schmitt, Michael:
> My company's COBOL coding standards are* to define binary fields as signed 
> (e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.
>
> The original standards were developed at least 40-60 years ago. They were 
> revised in 1994 but the signed binary guidance remained.
>
> One explanation could be if 50 years ago there were only signed binary 
> instructions such as ADD, but not logical instructions such as ADD LOGICAL. 
> Or maybe there were some logical instructions but not the full complement we 
> have today.
>
> Or it could be that whatever version of COBOL was used then (OS/VS COBOL or 
> earlier) was more efficient with signed binary, such as due to the choices it 
> made in instruction selection.
>
> So my question is, roughly when did the machines get unsigned binary 
> instructions for halfwords and fullwords?
>
>
> * "are" isn't the right word here, since the COBOL coding conventions are no 
> longer published anywhere. I only know what they are because I was on the 
> team that reviewed the 1994 revision, and have a copy saved.

Re: When did logical instructions appear?

[Robin Vowels]

From: "Farley, Peter x23353" <0dc9d8785c29-dmarc-requ...@listserv.uga.edu>
To: 
Sent: Friday, June 17, 2022 12:55 AM



There were already logical instructions as early as the 360 machine series.


They were around even earlier: at least by 1951 such instructions existed.

 However, early COBOL compilers (and even up to Enterprise V4) implemented the COBOL standard for 
numeric values by converting unsigned binary values to packed decimal and zeroing out any integer 
digits left of 4 digits for unsigned 9(4) COMP fields.  That "COBOL standards enforcement" code 
was slow because packed decimal instructions were significantly slower than binary ones on the 
early machines.



On much more recent z hardware the vector packed decimal instructions
are significantly faster than the non-vector versions and newer compilers
are taking advantage of those instructions. 



---
This email has been checked for viruses by Avast antivirus software.
https://www.avast.com/antivirus

Re: When did logical instructions appear?

[Robin Vowels]

From: "Tom Marchant" <00a69b48f3bb-dmarc-requ...@listserv.uga.edu>
To: 
Sent: Friday, June 17, 2022 12:58 AM



ADD LOGICAL and SUBTRACT LOGICAL were part of the original System/360,
and are documented in the A22-6821-0 edition of the System/360 Principles of 
Operation,
as well as in "Architecture of the IBM System/360", published in the IBM 
Journal in April,
1964, which describes the reasoning for many of the design choices.


There is no difference in the binary result between A and AL, S and SL.
The only difference is in the condition codes and capability of producing
an interrupt.

---
This email has been checked for viruses by Avast antivirus software.
https://www.avast.com/antivirus

Re: When did logical instructions appear?

[Robin Vowels]

From: "Seymour J Metz" 
To: 
Sent: Friday, June 17, 2022 1:07 AM


Unsigned binary arithmetic goes back at least to the 704 in 1955.


I already said that it goes back to 1951, at least.


I suspect that it goes back farther. There was no concept of halfword at the 
time;
it was all 36-bit words.



Logical AND, OR, etc. have comparable antiquity.


Logical AND, OR, EXCLUSIVE OR, etc, were already around by 1951.

---
This email has been checked for viruses by Avast antivirus software.
https://www.avast.com/antivirus

Re: When did logical instructions appear?

[Robin Vowels]

- Original Message - 
From: "Paul Gilmartin" <0014e0e4a59b-dmarc-requ...@listserv.uga.edu>

To: 
Sent: Friday, June 17, 2022 7:20 AM
Subject: Re: When did logical instructions appear?



On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:


Computers have had instructions for signed and unsigned binary
since at least 1951. When negative values are expressed using
twos complement notation, ordinary addition will give the same
result whether the operation is signed or unsigned.


It puzzles me that some of the oldest computers employed sign-
magnitude notation when 2's (1's, 10's) complement would have
needed fewer gates and fewer clock cycles.


For a serial machine (and most of them were in the early days),
twos complement was the simplest.  It needed only one cycle
for add and subtract.  Even subtract (complement and add one)
was done in a single cycle, "on the fly".  It was unnecessary to
add the one; complement commencing after the first non-zero bit.

Ones complement was a PITA, because a carry out of the high end
required a 1 to be added in the next cycle.  This was no good at
all for array machines such as Pilot ACE, DEUCE, and ACE,
because the word just summed would not have been around
to add the final "1" produced by the carry out -- the arithmetic
unit already working on summing (or subtracting) the next pair
of words.


Perhaps an accommodation to the engineers' habits.


---
This email has been checked for viruses by Avast antivirus software.
https://www.avast.com/antivirus

Re: When did logical instructions appear?

[Gary Weinhold]

My understanding was that using signed binary numbers made COBOL more efficient 
for arithmetic operations: L(H) a register, do the arithmetic and ST(H) the 
result.  Unsigned binary meant L(H) a register, force it positive, do the 
arithmetic, force the result positive, ST(H) the result.  (I'm pretty sure that 
COBOL treated unsigned binary fields as having to be positive numbers).


Gary Weinhold
Senior Application Architect
DATAKINETICS | Data Performance & Optimization
Phone:+1.613.523.5500 x216
Email: weinh...@dkl.com
Visit us online at www.DKL.com
E-mail Notification: The information contained in this email and any 
attachments is confidential and may be subject to copyright or other 
intellectual property protection. If you are not the intended recipient, you 
are not authorized to use or disclose this information, and we request that you 
notify us by reply mail or telephone and delete the original message from your 
mail system.


From: IBM Mainframe Assembler List  on behalf 
of Tom Marchant <00a69b48f3bb-dmarc-requ...@listserv.uga.edu>
Sent: June 16, 2022 10:58
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU 
Subject: Re: When did logical instructions appear?

ADD LOGICAL and SUBTRACT LOGICAL were part of the original System/360, and are 
documented in the A22-6821-0 edition of the System/360 Principles of Operation, 
as well as in "Architecture of the IBM System/360", published in the IBM 
Journal in April, 1964, which describes the reasoning for many of the design 
choices.

-- Tom Marchant

On Thu, 16 Jun 2022 14:36:12 +, Schmitt, Michael wrote:

>My company's COBOL coding standards are* to define binary fields as signed 
>(e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.
>
>The original standards were developed at least 40-60 years ago. They were 
>revised in 1994 but the signed binary guidance remained.
>
>One explanation could be if 50 years ago there were only signed binary 
>instructions such as ADD, but not logical instructions such as ADD LOGICAL. Or 
>maybe there were some logical instructions but not the full complement we have 
>today.
>
>Or it could be that whatever version of COBOL was used then (OS/VS COBOL or 
>earlier) was more efficient with signed binary, such as due to the choices it 
>made in instruction selection.
>
>So my question is, roughly when did the machines get unsigned binary 
>instructions for halfwords and fullwords?

Re: When did logical instructions appear?

[Paul Gilmartin]

On Jun 16, 2022, at 10:43:36, Robin Vowels wrote:


Computers have had instructions for signed and unsigned binary
since at least 1951.  When negative values are expressed using
twos complement notation, ordinary addition will give the same
result whether the operation is signed or unsigned.


It puzzles me that some of the oldest computers employed sign-
magnitude notation when 2's (1's, 10's) complement would have
needed fewer gates and fewer clock cycles.

Perhaps an accommodation to the engineers' habits.

--
gil

Re: When did logical instructions appear?

[Phil Smith III]

Steve Smith (no known relation) wrote:
>Every coding standard should document exactly why the standard exists, i.e.
>what benefit it provides.  That might help filter out, and allow for
>updating, of some long-gone person's personal preferences (which is where
>too many coding standards come from).

 

Indeed! that should go for any style guide-there are stylistic items that
*are* arbitrary, but which are there to ensure consistency ("Assembler
comments should start in column 40"), and those that seem arbitrary, but
aren't ("put DS 0H on labels, to reduce maintenance impact").

 

And then Peter Farley demonstrated Steve's precise point by explaining that
this particular item is likely based on old compilers on old hardware being
significantly slower for this use case! Great example.

 

I'm reminded of the lovely comments from the late Chris Stephenson of IBM in
the EXEC 2 source-I am of course paraphrasing but the code was something
like:

 LR   R1,R2  MOVE THE FROBNITZ

 MVC  THING2,THING1   DO THIS WHILE R2 SETTLES

 LR2,THING3

 

There were giants in those days.

Re: When did logical instructions appear?

[Robin Vowels]

On 2022-06-17 00:36, Schmitt, Michael wrote:

My company's COBOL coding standards are* to define binary fields as
signed (e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.

The original standards were developed at least 40-60 years ago. They
were revised in 1994 but the signed binary guidance remained.

One explanation could be if 50 years ago there were only signed binary
instructions such as ADD, but not logical instructions such as ADD
LOGICAL. Or maybe there were some logical instructions but not the
full complement we have today.

Or it could be that whatever version of COBOL was used then (OS/VS
COBOL or earlier) was more efficient with signed binary, such as due
to the choices it made in instruction selection.

So my question is, roughly when did the machines get unsigned binary
instructions for halfwords and fullwords?


Computers have had instructions for signed and unsigned binary
since at least 1951.  When negative values are expressed using
twos complement notation, ordinary addition will give the same
result whether the operation is signed or unsigned.


* "are" isn't the right word here, since the COBOL coding conventions
are no longer published anywhere. I only know what they are because I
was on the team that reviewed the 1994 revision, and have a copy
saved.

Re: When did logical instructions appear?

[Seymour J Metz]

Unsigned binary arithmetic goes back at least to the 704 in 1955. I suspect 
that it goes back farther. There was no concept of halfword at the time; it was 
all 36-bit words.

Logical AND, OR, etc. have comparable antiquity.


--
Shmuel (Seymour J.) Metz
http://mason.gmu.edu/~smetz3


From: IBM Mainframe Assembler List [ASSEMBLER-LIST@LISTSERV.UGA.EDU] on behalf 
of Schmitt, Michael [michael.schm...@dxc.com]
Sent: Thursday, June 16, 2022 10:36 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: When did logical instructions appear?

My company's COBOL coding standards are* to define binary fields as signed 
(e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.

The original standards were developed at least 40-60 years ago. They were 
revised in 1994 but the signed binary guidance remained.

One explanation could be if 50 years ago there were only signed binary 
instructions such as ADD, but not logical instructions such as ADD LOGICAL. Or 
maybe there were some logical instructions but not the full complement we have 
today.

Or it could be that whatever version of COBOL was used then (OS/VS COBOL or 
earlier) was more efficient with signed binary, such as due to the choices it 
made in instruction selection.

So my question is, roughly when did the machines get unsigned binary 
instructions for halfwords and fullwords?


* "are" isn't the right word here, since the COBOL coding conventions are no 
longer published anywhere. I only know what they are because I was on the team 
that reviewed the 1994 revision, and have a copy saved.

Re: When did logical instructions appear?

[Binyamin Dissen]

On Thu, 16 Jun 2022 14:36:12 + "Schmitt, Michael"
 wrote:

:>My company's COBOL coding standards are* to define binary fields as signed 
(e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.

Because it takes extra instructions to get the absolute value.

--
Binyamin Dissen 
http://www.dissensoftware.com

Director, Dissen Software, Bar & Grill - Israel

Re: When did logical instructions appear?

[Schmitt, Michael]

Specifying 9(4) or S9(4) can have a maximum value of 9,999 (i.e. 4 decimal 
digits), depending on the chosen TRUNC compiler option.

TRUNC(BIN) means to truncate at the halfword or fullword. But we use 
TRUNC(OPT), which means "do whatever is the most efficient", which can truncate 
at .

So that's a good point: with TRUNC other than TRUNC(BIN), 9(4) or S9(4) has the 
same maximum value.



-Original Message-
From: IBM Mainframe Assembler List  On Behalf 
Of Dave Clark
Sent: Thursday, June 16, 2022 9:54 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: Re: When did logical instructions appear?

"IBM Mainframe Assembler List"  wrote on
06/16/2022 10:36:12 AM:
> Or it could be that whatever version of COBOL was used then (OS/VS
> COBOL or earlier) was more efficient with signed binary, such as due
> to the choices it made in instruction selection.


My understanding, at least for VSE, is that COBOL does not really
support unsigned numbers.  Instead, if the S designation is not coded then
COBOL simply forces a positive number.  Thus, in the case of binary,
specifying 9(4) or S9(4) still has a max possible value of 32,767 either
way.  Therefore, the only benefit of using an unsigned PIC is to prevent
negative numbers.  Otherwise, yes, you do save a little on performance by
using the S designation so that COBOL doesn't have to go to the extra
effort of forcing a positive sign.


Sincerely,

Dave Clark
--
int.ext: 91078
direct: (937) 531-6378
home: (937) 751-3300

Winsupply Group Services
3110 Kettering Boulevard
Dayton, Ohio  45439  USA
(937) 294-5331




*
This email message and any attachments is for use only by the named
addressee(s) and may contain confidential, privileged and/or proprietary
information. If you have received this message in error, please
immediately notify the sender and delete and destroy the message and all
copies. All unauthorized direct or indirect use or disclosure of this
message is strictly prohibited. No right to confidentiality or privilege
is waived or lost by any error in transmission.
*

Re: When did logical instructions appear?

[Tom Marchant]

ADD LOGICAL and SUBTRACT LOGICAL were part of the original System/360, and are 
documented in the A22-6821-0 edition of the System/360 Principles of Operation, 
as well as in "Architecture of the IBM System/360", published in the IBM 
Journal in April, 1964, which describes the reasoning for many of the design 
choices.

-- Tom Marchant

On Thu, 16 Jun 2022 14:36:12 +, Schmitt, Michael wrote:

>My company's COBOL coding standards are* to define binary fields as signed 
>(e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.
>
>The original standards were developed at least 40-60 years ago. They were 
>revised in 1994 but the signed binary guidance remained.
>
>One explanation could be if 50 years ago there were only signed binary 
>instructions such as ADD, but not logical instructions such as ADD LOGICAL. Or 
>maybe there were some logical instructions but not the full complement we have 
>today.
>
>Or it could be that whatever version of COBOL was used then (OS/VS COBOL or 
>earlier) was more efficient with signed binary, such as due to the choices it 
>made in instruction selection.
>
>So my question is, roughly when did the machines get unsigned binary 
>instructions for halfwords and fullwords?

Re: When did logical instructions appear?

[Farley, Peter x23353]

There were already logical instructions as early as the 360 machine series.  
However, early COBOL compilers (and even up to Enterprise V4) implemented the 
COBOL standard for numeric values by converting unsigned binary values to 
packed decimal and zeroing out any integer digits left of 4 digits for unsigned 
9(4) COMP fields.  That "COBOL standards enforcement" code was slow because 
packed decimal instructions were significantly slower than binary ones on the 
early machines.

On much more recent z hardware the vector packed decimal instructions are 
significantly faster than the non-vector versions and newer compilers are 
taking advantage of those instructions.

HTH

-Original Message-
From: IBM Mainframe Assembler List  On Behalf 
Of Schmitt, Michael
Sent: Thursday, June 16, 2022 10:36 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: When did logical instructions appear?

My company's COBOL coding standards are* to define binary fields as signed 
(e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.

The original standards were developed at least 40-60 years ago. They were 
revised in 1994 but the signed binary guidance remained.

One explanation could be if 50 years ago there were only signed binary 
instructions such as ADD, but not logical instructions such as ADD LOGICAL. Or 
maybe there were some logical instructions but not the full complement we have 
today.

Or it could be that whatever version of COBOL was used then (OS/VS COBOL or 
earlier) was more efficient with signed binary, such as due to the choices it 
made in instruction selection.

So my question is, roughly when did the machines get unsigned binary 
instructions for halfwords and fullwords?


* "are" isn't the right word here, since the COBOL coding conventions are no 
longer published anywhere. I only know what they are because I was on the team 
that reviewed the 1994 revision, and have a copy saved.

This message and any attachments are intended only for the use of the addressee 
and may contain information that is privileged and confidential. If the reader 
of the message is not the intended recipient or an authorized representative of 
the intended recipient, you are hereby notified that any dissemination of this 
communication is strictly prohibited. If you have received this communication 
in error, please notify us immediately by e-mail and delete the message and any 
attachments from your system.

Re: When did logical instructions appear?

[Charles Mills]

Many logical instructions -- fullword and character anyway -- go back to the
very first System 360's.

I've got a System 370 Yellow Card here and it includes AL, ALR, CL, CLR, SL
and SLR as System 360 instructions.

Charles


-Original Message-
From: IBM Mainframe Assembler List [mailto:ASSEMBLER-LIST@LISTSERV.UGA.EDU]
On Behalf Of Schmitt, Michael
Sent: Thursday, June 16, 2022 7:36 AM
To: ASSEMBLER-LIST@LISTSERV.UGA.EDU
Subject: When did logical instructions appear?

My company's COBOL coding standards are* to define binary fields as signed
(e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.

The original standards were developed at least 40-60 years ago. They were
revised in 1994 but the signed binary guidance remained.

One explanation could be if 50 years ago there were only signed binary
instructions such as ADD, but not logical instructions such as ADD LOGICAL.
Or maybe there were some logical instructions but not the full complement we
have today.

Or it could be that whatever version of COBOL was used then (OS/VS COBOL or
earlier) was more efficient with signed binary, such as due to the choices
it made in instruction selection.

So my question is, roughly when did the machines get unsigned binary
instructions for halfwords and fullwords?


* "are" isn't the right word here, since the COBOL coding conventions are no
longer published anywhere. I only know what they are because I was on the
team that reviewed the 1994 revision, and have a copy saved.

Re: When did logical instructions appear?

[Dave Clark]

"IBM Mainframe Assembler List"  wrote on 
06/16/2022 10:36:12 AM:
> Or it could be that whatever version of COBOL was used then (OS/VS 
> COBOL or earlier) was more efficient with signed binary, such as due
> to the choices it made in instruction selection.


My understanding, at least for VSE, is that COBOL does not really 
support unsigned numbers.  Instead, if the S designation is not coded then 
COBOL simply forces a positive number.  Thus, in the case of binary, 
specifying 9(4) or S9(4) still has a max possible value of 32,767 either 
way.  Therefore, the only benefit of using an unsigned PIC is to prevent 
negative numbers.  Otherwise, yes, you do save a little on performance by 
using the S designation so that COBOL doesn't have to go to the extra 
effort of forcing a positive sign.


Sincerely,

Dave Clark
-- 
int.ext: 91078
direct: (937) 531-6378
home: (937) 751-3300

Winsupply Group Services
3110 Kettering Boulevard
Dayton, Ohio  45439  USA
(937) 294-5331




*
This email message and any attachments is for use only by the named 
addressee(s) and may contain confidential, privileged and/or proprietary 
information. If you have received this message in error, please 
immediately notify the sender and delete and destroy the message and all 
copies. All unauthorized direct or indirect use or disclosure of this 
message is strictly prohibited. No right to confidentiality or privilege 
is waived or lost by any error in transmission. 
*

Re: When did logical instructions appear?

[Steve Smith]

The logical instructions were in there from the get-go.  I have no idea
what the implications were or are for COBOL.

Every coding standard should document exactly why the standard exists, i.e.
what benefit it provides.  That might help filter out, and allow for
updating, of some long-gone person's personal preferences (which is where
too many coding standards come from).

sas

On Thu, Jun 16, 2022 at 10:36 AM Schmitt, Michael 
wrote:

> My company's COBOL coding standards are* to define binary fields as signed
> (e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.
>
> The original standards were developed at least 40-60 years ago. They were
> revised in 1994 but the signed binary guidance remained.
>
> One explanation could be if 50 years ago there were only signed binary
> instructions such as ADD, but not logical instructions such as ADD LOGICAL.
> Or maybe there were some logical instructions but not the full complement
> we have today.
>
> Or it could be that whatever version of COBOL was used then (OS/VS COBOL
> or earlier) was more efficient with signed binary, such as due to the
> choices it made in instruction selection.
>
> So my question is, roughly when did the machines get unsigned binary
> instructions for halfwords and fullwords?
>
>
> * "are" isn't the right word here, since the COBOL coding conventions are
> no longer published anywhere. I only know what they are because I was on
> the team that reviewed the 1994 revision, and have a copy saved.
>

When did logical instructions appear?

[Schmitt, Michael]

My company's COBOL coding standards are* to define binary fields as signed 
(e.g. PIC S9(4) BINARY). I'm wondering why that's the standard.

The original standards were developed at least 40-60 years ago. They were 
revised in 1994 but the signed binary guidance remained.

One explanation could be if 50 years ago there were only signed binary 
instructions such as ADD, but not logical instructions such as ADD LOGICAL. Or 
maybe there were some logical instructions but not the full complement we have 
today.

Or it could be that whatever version of COBOL was used then (OS/VS COBOL or 
earlier) was more efficient with signed binary, such as due to the choices it 
made in instruction selection.

So my question is, roughly when did the machines get unsigned binary 
instructions for halfwords and fullwords?


* "are" isn't the right word here, since the COBOL coding conventions are no 
longer published anywhere. I only know what they are because I was on the team 
that reviewed the 1994 revision, and have a copy saved.