Discussion:
xkcd: x
Add Reply
Lynn McGuire
2020-05-21 18:45:09 UTC
Reply
Permalink
xkcd: x
https://xkcd.com/2309/

I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.

Explained at:
https://www.explainxkcd.com/wiki/index.php/2309:_X

Lynn
Thomas Koenig
2020-05-21 18:56:29 UTC
Reply
Permalink
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?

Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Lynn McGuire
2020-05-21 19:07:08 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.

Lynn
Dorothy J Heydt
2020-05-21 19:49:25 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I asked Hal (EECS) if he wanted to comment, and he said, "No, not
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
gonna touch that." :)
Robert Carnegie
2020-05-21 20:14:03 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I asked Hal (EECS) if he wanted to comment, and he said,
"y?" :-)

I mentioned in
<https://www.explainxkcd.com/wiki/index.php/Talk:2309:_X>
that I've programmed using variables without names
but I am trying to give that up. It does save effort of
thinking of a name, and not a misleading one, but...
Dorothy J Heydt
2020-05-21 21:51:18 UTC
Reply
Permalink
Post by Robert Carnegie
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I asked Hal (EECS) if he wanted to comment, and he said,
"y?" :-)
Sorry, last line got truncated. He said, "No. Not gonna go
there."
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Thomas Koenig
2020-05-22 06:46:42 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.

Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
Dorothy J Heydt
2020-05-22 14:32:00 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
You bettah off. I once (briefly) had a side job keypunching
lines of *Sanskrit* verse into punch cards so that some student
could do an analysis. I made too many mistakes and got fired.
I was bettah off too.
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Thomas Koenig
2020-05-22 15:30:19 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
You bettah off. I once (briefly) had a side job keypunching
lines of *Sanskrit* verse into punch cards so that some student
could do an analysis.
Well, for β or worse, that was the equipment that was available at
the time, I guess.
Post by Dorothy J Heydt
I made too many mistakes and got fired.
I was bettah off too.
Small wonder. What encoding did you use, and what did your
original text look like? I don't suppose it was something like
संस्कृतम्, was it?
Chrysi Cat
2020-05-22 15:37:35 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
You bettah off. I once (briefly) had a side job keypunching
lines of *Sanskrit* verse into punch cards so that some student
could do an analysis.
Well, for β or worse, that was the equipment that was available at
the time, I guess.
Post by Dorothy J Heydt
I made too many mistakes and got fired.
I was bettah off too.
Small wonder. What encoding did you use, and what did your
original text look like? I don't suppose it was something like
संस्कृतम्, was it?
Oh, wow. You really wanted to kick that wasp's nest, eh?

There are some people who will never upgrade to UTF-8 clients and
they're about to all come in here asking what that garbled string of
ASCII characters on their screen is.

Though admittedly, you couldn't make ether the "beta" joke or the one
with the Devanagari without encoding your message in it ;-P
--
Chrysi Cat
1/2 anthrocat, nearly 1/2 anthrofox, all magical
Transgoddess, quick to anger.
Call me Chrysi or call me Kat, I'll respond to either!
Dorothy J Heydt
2020-05-22 16:28:38 UTC
Reply
Permalink
Post by Chrysi Cat
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
You bettah off. I once (briefly) had a side job keypunching
lines of *Sanskrit* verse into punch cards so that some student
could do an analysis.
Well, for β or worse, that was the equipment that was available at
the time, I guess.
Post by Dorothy J Heydt
I made too many mistakes and got fired.
I was bettah off too.
Small wonder. What encoding did you use, and what did your
original text look like? I don't suppose it was something like
à€žà€‚à€žà¥à€•à¥ƒà€€à€®à¥, was it?
I can't even read that, but no.

This was like, 1964. The keypunch code was straight ASCII (or
whatever came before ASCII) alphanumeric. The student had set
up a set of two-character strings to represent, for instance, a
character that looked like m with a dot under it; I forget now
whether it was dot followed by m, or the reverse.
Post by Chrysi Cat
Oh, wow. You really wanted to kick that wasp's nest, eh?
There are some people who will never upgrade to UTF-8 clients and
they're about to all come in here asking what that garbled string of
ASCII characters on their screen is.
/raises hand

I have no idea what that string was supposed to look like; either
it's a lot of backslash-x-alpha-numeric, or else a dazzling array
of non-ASCII characters.
Post by Chrysi Cat
Though admittedly, you couldn't make ether the "beta" joke or the one
with the Devanagari without encoding your message in it ;-P
Back in around 1963, I could *read* devanagari, having just
finished a year's course in Sanskrit (required for the
linguistics major). But there was no way of properly encoding
devanagari on punch cards.
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Chrysi Cat
2020-05-22 16:48:38 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Chrysi Cat
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
You bettah off. I once (briefly) had a side job keypunching
lines of *Sanskrit* verse into punch cards so that some student
could do an analysis.
Well, for β or worse, that was the equipment that was available at
the time, I guess.
Post by Dorothy J Heydt
I made too many mistakes and got fired.
I was bettah off too.
Small wonder. What encoding did you use, and what did your
original text look like? I don't suppose it was something like
संस्कृतम्, was it?
I can't even read that, but no.
This was like, 1964. The keypunch code was straight ASCII (or
whatever came before ASCII) alphanumeric. The student had set
up a set of two-character strings to represent, for instance, a
character that looked like m with a dot under it; I forget now
whether it was dot followed by m, or the reverse.
Post by Chrysi Cat
Oh, wow. You really wanted to kick that wasp's nest, eh?
There are some people who will never upgrade to UTF-8 clients and
they're about to all come in here asking what that garbled string of
ASCII characters on their screen is.
/raises hand
I have no idea what that string was supposed to look like; either
it's a lot of backslash-x-alpha-numeric, or else a dazzling array
of non-ASCII characters.
It's the latter. Specifically, it's actual devanagari.

And the stray characters in the earlier section of his post before your
mentioning that you got fired, add up to "beta" in UTF-8.
Post by Dorothy J Heydt
Post by Chrysi Cat
Though admittedly, you couldn't make ether the "beta" joke or the one
with the Devanagari without encoding your message in it ;-P
Back in around 1963, I could *read* devanagari, having just
finished a year's course in Sanskrit (required for the
linguistics major). But there was no way of properly encoding
devanagari on punch cards.
--
Chrysi Cat
1/2 anthrocat, nearly 1/2 anthrofox, all magical
Transgoddess, quick to anger.
Call me Chrysi or call me Kat, I'll respond to either!
Mark Jackson
2020-05-22 19:35:34 UTC
Reply
Permalink
Post by Dorothy J Heydt
This was like, 1964. The keypunch code was straight ASCII (or
whatever came before ASCII) alphanumeric.
Binary-Coded Decimal or possibly its successor EBCDIC; the latter came
in with the 029 keypunch accompanying the then-new System 360.
--
Mark Jackson - http://www.alumni.caltech.edu/~mjackson
After a certain point in one's career, the worry that
they'll finally notice your true absence of talent
morphs into worrying that they'll finally notice
that you've Lost It. - William Gibson
Dorothy J Heydt
2020-05-22 21:21:08 UTC
Reply
Permalink
Post by Mark Jackson
Post by Dorothy J Heydt
This was like, 1964. The keypunch code was straight ASCII (or
whatever came before ASCII) alphanumeric.
Binary-Coded Decimal or possibly its successor EBCDIC; the latter came
in with the 029 keypunch accompanying the then-new System 360.
Whatever. It printed out as alpha on the top edge of the card.
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
John W Kennedy
2020-05-22 22:02:29 UTC
Reply
Permalink
Post by Mark Jackson
This was like, 1964.  The keypunch code was straight ASCII (or
whatever came before ASCII) alphanumeric.
Binary-Coded Decimal or possibly its successor EBCDIC; the latter came
in with the 029 keypunch accompanying the then-new System 360.
I don’t believe any 360s or 029s shipped in calendar year 1964, so it
would have been BCD, later to be retronymed BCDIC, on an 024 or 026
keypunch.
--
John W. Kennedy
"The blind rulers of Logres
Nourished the land on a fallacy of rational virtue."
-- Charles Williams. "Taliessin through Logres: Prelude"
Thomas Koenig
2020-05-22 22:30:14 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
You bettah off. I once (briefly) had a side job keypunching
lines of *Sanskrit* verse into punch cards so that some student
could do an analysis.
Well, for β or worse, that was the equipment that was available at
the time, I guess.
Post by Dorothy J Heydt
I made too many mistakes and got fired.
I was bettah off too.
Small wonder. What encoding did you use, and what did your
original text look like? I don't suppose it was something like
संस्कृतम्, was it?
I can't even read that, but no.
This was like, 1964. The keypunch code was straight ASCII (or
whatever came before ASCII) alphanumeric. The student had set
up a set of two-character strings to represent, for instance, a
character that looked like m with a dot under it; I forget now
whether it was dot followed by m, or the reverse.
Funny thing, what you could presumably punch then (80 columns,
US letters and some special characters) is pretty much what your
newsreader can display now, at least if you want to stay within
current Usenet recommendations.

I guess that's progress, or lack thereof...
Peter Trei
2020-05-23 03:00:58 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
You bettah off. I once (briefly) had a side job keypunching
lines of *Sanskrit* verse into punch cards so that some student
could do an analysis.
Well, for β or worse, that was the equipment that was available at
the time, I guess.
Post by Dorothy J Heydt
I made too many mistakes and got fired.
I was bettah off too.
Small wonder. What encoding did you use, and what did your
original text look like? I don't suppose it was something like
संस्कृतम्, was it?
I can't even read that, but no.
This was like, 1964. The keypunch code was straight ASCII (or
whatever came before ASCII) alphanumeric. The student had set
up a set of two-character strings to represent, for instance, a
character that looked like m with a dot under it; I forget now
whether it was dot followed by m, or the reverse.
Funny thing, what you could presumably punch then (80 columns,
US letters and some special characters) is pretty much what your
newsreader can display now, at least if you want to stay within
current Usenet recommendations.
I guess that's progress, or lack thereof...
The 80x24 screens of many character cell terminals, even using ascii and not from
IBM, emulated the IBM 3270 terminal, which in turn had 80 columns for
compatibility with punched cards. Usenet got its 80 character lines from those
terminals.

Pt
Mark Jackson
2020-05-22 14:51:34 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
I'm a physicist; I don't remember doing that but can't be sure my first,
very simple program (in Fortran) used sensible variable names.

I do recall a bit later using names of no more than two characters, but
that was in an early Basic that only supported 26*11 different variable
names.
Post by Thomas Koenig
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
Started on an IBM 026 keypunch feeding Fortran into a 7094.
--
Mark Jackson - http://www.alumni.caltech.edu/~mjackson
After a certain point in one's career, the worry that
they'll finally notice your true absence of talent
morphs into worrying that they'll finally notice
that you've Lost It. - William Gibson
Lynn McGuire
2020-05-22 18:38:45 UTC
Reply
Permalink
Post by Mark Jackson
Post by Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
      https://xkcd.com/2309/
I say that we tar and feather Cueball.  The base code of my
calculation
engine was written in Fortran II back in the middle 1960s.  I have
entire subroutines with only one letter variables names.  X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering).  Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
I'm a physicist; I don't remember doing that but can't be sure my first,
very simple program (in Fortran) used sensible variable names.
I do recall a bit later using names of no more than two characters, but
that was in an early Basic that only supported 26*11 different variable
names.
Post by Thomas Koenig
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
Started on an IBM 026 keypunch feeding Fortran into a 7094.>
The Basic on my 1980 TRS-80 Pocket Computer only supports 26 single
character variables. You can probably guess what they are. BTW, I
still own it but the display is fragged.
https://en.wikipedia.org/wiki/Sharp_PC-1211

Lynn
David Goldfarb
2020-05-23 01:23:34 UTC
Reply
Permalink
Post by Lynn McGuire
The Basic on my 1980 TRS-80 Pocket Computer only supports 26 single
character variables. You can probably guess what they are.
However, during the Christmas season it only supports 25.
--
David Goldfarb | "And it came to pass by the way in the inn,
***@gmail.com | that the LORD met him, and sought to kill him."
***@ocf.berkeley.edu | -- Exodus 4:24
Lynn McGuire
2020-05-22 18:42:59 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
I am putting the equations in this paper into my engineering software
right now. All of the variables in the equations are one or two characters.

https://valves.bakerhughes.com/sites/g/files/cozyhq631/files/2019-11/MN-Valve-Sizing-Handbook-GEA19540A-English.pdf

Lynn
Thomas Koenig
2020-05-22 22:40:50 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
I am putting the equations in this paper into my engineering software
right now. All of the variables in the equations are one or two characters.
https://valves.bakerhughes.com/sites/g/files/cozyhq631/files/2019-11/MN-Valve-Sizing-Handbook-GEA19540A-English.pdf
Table 1 has

"Numerical Constants for Liquid Flow Equations"

and gives different constants for when certain quantities are in
certain units.

Argh.

Physical relationships have _one_ form, which is independent of
units. This is basic physics (and the basis for dimensional
analysis).

I once even read the formula for the Reynolds number as

Re = (u * d * rho) / (K * eta)

where K was a unit correction factor. The horror!
Lynn McGuire
2020-05-22 22:50:56 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Grad students (engineering). Engineers are famous for writing entire
multiple page mathematical expressions using single characters.
I'm an engineer, and I don't do that.
Different generation, I guess (but then I missed using punched cards
at university by a couple of years).
I am putting the equations in this paper into my engineering software
right now. All of the variables in the equations are one or two characters.
https://valves.bakerhughes.com/sites/g/files/cozyhq631/files/2019-11/MN-Valve-Sizing-Handbook-GEA19540A-English.pdf
Table 1 has
"Numerical Constants for Liquid Flow Equations"
and gives different constants for when certain quantities are in
certain units.
Argh.
Physical relationships have _one_ form, which is independent of
units. This is basic physics (and the basis for dimensional
analysis).
I once even read the formula for the Reynolds number as
Re = (u * d * rho) / (K * eta)
where K was a unit correction factor. The horror!
Dimensional Units are a never ending source of grief for us. We support
four temperature units, 17 pressure units (gauge and absolute), etc,
etc, etc.

Lynn
Thomas Koenig
2020-05-23 16:28:06 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
https://valves.bakerhughes.com/sites/g/files/cozyhq631/files/2019-11/MN-Valve-Sizing-Handbook-GEA19540A-English.pdf
Table 1 has
"Numerical Constants for Liquid Flow Equations"
and gives different constants for when certain quantities are in
certain units.
Argh.
Physical relationships have _one_ form, which is independent of
units. This is basic physics (and the basis for dimensional
analysis).
I once even read the formula for the Reynolds number as
Re = (u * d * rho) / (K * eta)
where K was a unit correction factor. The horror!
Dimensional Units are a never ending source of grief for us. We support
four temperature units, 17 pressure units (gauge and absolute), etc,
etc, etc.
Let's see... Kelvin, Celsius, Fahrenheit, and Rankine?

For pressure - let me see how many I get without lookingn them up.

For your software - how do you actually deal with gauge pressures,
what do you use as a reference? It can make a difference.

I remember when a member of the board of the BASF gave a lecture at
my university. He told us about a plant in Turkey, at around 1000
m elevation, where they build air compressors and suddenly realized
on startup that air at that altitude is only ~90% of the density...

They had left enough margin so they still reached the specified
output, but it was close.

Also, for your sake I hope you only use one consistend unit system
for calculation, and only do conversion on I/O. If not, you must
have been living through interesting times (in the sense of the
alleged Chinese proverb, which Chinese generally don't know).
Thomas Koenig
2020-05-23 16:48:22 UTC
Reply
Permalink
Post by Thomas Koenig
For pressure - let me see how many I get without lookingn them up.
I failed to delete that line.
Mark Jackson
2020-05-23 17:02:47 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Thomas Koenig
For pressure - let me see how many I get without lookingn them up.
I failed to delete that line.
No pressure.
--
Mark Jackson - http://www.alumni.caltech.edu/~mjackson
After a certain point in one's career, the worry that
they'll finally notice your true absence of talent
morphs into worrying that they'll finally notice
that you've Lost It. - William Gibson
Thomas Koenig
2020-05-23 17:10:21 UTC
Reply
Permalink
Post by Mark Jackson
Post by Thomas Koenig
Post by Thomas Koenig
For pressure - let me see how many I get without lookingn them up.
I failed to delete that line.
No pressure.
But will I be gauged by this?
Kevrob
2020-05-23 17:33:26 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Mark Jackson
Post by Thomas Koenig
Post by Thomas Koenig
For pressure - let me see how many I get without lookingn them up.
I failed to delete that line.
No pressure.
But will I be gauged by this?
Nobody will leak anything if they do.

Kevin R
John W Kennedy
2020-05-23 18:04:11 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
https://valves.bakerhughes.com/sites/g/files/cozyhq631/files/2019-11/MN-Valve-Sizing-Handbook-GEA19540A-English.pdf
Table 1 has
"Numerical Constants for Liquid Flow Equations"
and gives different constants for when certain quantities are in
certain units.
Argh.
Physical relationships have _one_ form, which is independent of
units. This is basic physics (and the basis for dimensional
analysis).
I once even read the formula for the Reynolds number as
Re = (u * d * rho) / (K * eta)
where K was a unit correction factor. The horror!
Dimensional Units are a never ending source of grief for us. We support
four temperature units, 17 pressure units (gauge and absolute), etc,
etc, etc.
Let's see... Kelvin, Celsius, Fahrenheit, and Rankine?
My mid-60s Handbook also lists Réaumur: 0–80 Réaumur == 0–100 Celsius.
Post by Thomas Koenig
For pressure - let me see how many I get without lookingn them up.
For your software - how do you actually deal with gauge pressures,
what do you use as a reference? It can make a difference.
I remember when a member of the board of the BASF gave a lecture at
my university. He told us about a plant in Turkey, at around 1000
m elevation, where they build air compressors and suddenly realized
on startup that air at that altitude is only ~90% of the density...
They had left enough margin so they still reached the specified
output, but it was close.
Also, for your sake I hope you only use one consistend unit system
for calculation, and only do conversion on I/O. If not, you must
have been living through interesting times (in the sense of the
alleged Chinese proverb, which Chinese generally don't know).
--
John W. Kennedy
"The blind rulers of Logres
Nourished the land on a fallacy of rational virtue."
-- Charles Williams. "Taliessin through Logres: Prelude"
Mark Jackson
2020-05-23 18:37:43 UTC
Reply
Permalink
Post by John W Kennedy
Post by Thomas Koenig
Post by Lynn McGuire
Dimensional Units are a never ending source of grief for us. We
support four temperature units, 17 pressure units (gauge and
absolute), etc, etc, etc.
Let's see... Kelvin, Celsius, Fahrenheit, and Rankine?
My mid-60s Handbook also lists Réaumur: 0–80 Réaumur == 0–100 Celsius.
Not to be confused with the Rømer scale (mentioned in
https://xkcd.com/2292/).
--
Mark Jackson - http://www.alumni.caltech.edu/~mjackson
After a certain point in one's career, the worry that
they'll finally notice your true absence of talent
morphs into worrying that they'll finally notice
that you've Lost It. - William Gibson
Lynn McGuire
2020-05-23 22:37:17 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
https://valves.bakerhughes.com/sites/g/files/cozyhq631/files/2019-11/MN-Valve-Sizing-Handbook-GEA19540A-English.pdf
Table 1 has
"Numerical Constants for Liquid Flow Equations"
and gives different constants for when certain quantities are in
certain units.
Argh.
Physical relationships have _one_ form, which is independent of
units. This is basic physics (and the basis for dimensional
analysis).
I once even read the formula for the Reynolds number as
Re = (u * d * rho) / (K * eta)
where K was a unit correction factor. The horror!
Dimensional Units are a never ending source of grief for us. We support
four temperature units, 17 pressure units (gauge and absolute), etc,
etc, etc.
Let's see... Kelvin, Celsius, Fahrenheit, and Rankine?
For pressure - let me see how many I get without lookingn them up.
For your software - how do you actually deal with gauge pressures,
what do you use as a reference? It can make a difference.
I remember when a member of the board of the BASF gave a lecture at
my university. He told us about a plant in Turkey, at around 1000
m elevation, where they build air compressors and suddenly realized
on startup that air at that altitude is only ~90% of the density...
They had left enough margin so they still reached the specified
output, but it was close.
Also, for your sake I hope you only use one consistend unit system
for calculation, and only do conversion on I/O. If not, you must
have been living through interesting times (in the sense of the
alleged Chinese proverb, which Chinese generally don't know).
Temperature: yes, F, C, R and K

Pressure: "psia", "psig", "atm", "mm Hg", "bar", "kg/cm2",
"kg/m2", "dynes/cm2", "g/cm2", "Pa", "kPa", "atmg",
"barg", "kg/cm2g", "kg/m2g", "dy/cm2g", "g/cm2g",
"Pag", "kPag", "MPa", "MPag", "inH2O", "inH2Og",
"mmH2O", "mmH2Og"

Our base pressure is 14.696 psia but users can override that.

Yup, one must take base pressure into account for plants. One must also
take expected winter and summer extreme temperatures into account.

Our software is a Frankenstein. It consists of several programs that
have been munged together over the years. As is such, our most common
dimensional units for the internal calculations are R and psia. But we
also have K and Pascals in some areas, transitioning is very careful and
difficult.

You can read more of our capabilities and history if you are interested
(7 MB download).
https://www.winsim.com/media/diiw_brochure.pdf

Lynn
Thomas Koenig
2020-05-24 07:04:16 UTC
Reply
Permalink
Post by Lynn McGuire
You can read more of our capabilities and history if you are interested
(7 MB download).
https://www.winsim.com/media/diiw_brochure.pdf
Question: I've only used Aspen Plus a couple of times, but I was
not amused by the fact that, by restarting a converged solution,
you could get a diverging solution. You often have to disturb the
solution to get it to converge again.

To anybody who's ever used multi-dimensional Newton to solve a
non-linear problem, this is bizarre. It's like they use Mathematics
from before calculus was invented.

If your software does not have the same problem, I would put it
into your brochure. If it does, well... what about fixing it?
Lynn McGuire
2020-05-25 00:08:28 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
You can read more of our capabilities and history if you are interested
(7 MB download).
https://www.winsim.com/media/diiw_brochure.pdf
Question: I've only used Aspen Plus a couple of times, but I was
not amused by the fact that, by restarting a converged solution,
you could get a diverging solution. You often have to disturb the
solution to get it to converge again.
To anybody who's ever used multi-dimensional Newton to solve a
non-linear problem, this is bizarre. It's like they use Mathematics
from before calculus was invented.
If your software does not have the same problem, I would put it
into your brochure. If it does, well... what about fixing it?
Aspen Plus and our software are radically different chemical process
simulators. Aspen Plus is based on the old Monsanto FLOWTRAN program.
Our software is based on the old CHESS program, Chemical Engineer
Simulation Software.

I don't understand what you mean by restarting a converged solution.
Once converged is always converged in our software. Unless, you are
talking about changing release versions then, all bets are off if a bug
was fixed, more data added, or a new feature added (we just added solids
to our flashes in version 16.00).

All Chemical Process Simulators are non linear solvers. As the mixtures
pass through the various phases (solid, hydrocarbon liquid, aqueous
liquid, vapor) they cause discontinuities. Managing those
discontinuities is what we do for a living.

Lynn
Gary R. Schmidt
2020-05-25 03:33:29 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Thomas Koenig
Post by Lynn McGuire
You can read more of our capabilities and history if you are interested
(7 MB download).
     https://www.winsim.com/media/diiw_brochure.pdf
Question: I've only used Aspen Plus a couple of times, but I was
not amused by the fact that, by restarting a converged solution,
you could get a diverging solution. You often have to disturb the
solution to get it to converge again.
To anybody who's ever used multi-dimensional Newton to solve a
non-linear problem, this is bizarre.  It's like they use Mathematics
from before calculus was invented.
If your software does not have the same problem, I would put it
into your brochure.  If it does, well... what about fixing it?
Aspen Plus and our software are radically different chemical process
simulators.  Aspen Plus is based on the old Monsanto FLOWTRAN program.
Our software is based on the old CHESS program, Chemical Engineer
Simulation Software.
Gaaah! Two names I had hoped never to see again, in a chemical
computing context.

Curse you Red Baron!!!

Cheers,
Gary B-)
--
Waiting for a new signature to suggest itself...
Thomas Koenig
2020-05-25 06:04:30 UTC
Reply
Permalink
Post by Lynn McGuire
I don't understand what you mean by restarting a converged solution.
By which I mean:

1. Run a calculation until a converged solution has been achieved
2. Restart the calculation with the same values just calculated
3. Watch it diverge

without re-starting the software or anything else, just click on
the button. For this to happen, there has to be a recycle stream.

I did mention bizarre.

(Probably something to do with the way runs the different
blocks sequentially).
Post by Lynn McGuire
Once converged is always converged in our software.
Good for you, then. Maybe this is a sentence you could put in
your brochure. People who've had experience of the phenomenon I
described will appreciate it, and people who don't will just take
it as given.
Lynn McGuire
2020-05-25 07:42:54 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
I don't understand what you mean by restarting a converged solution.
1. Run a calculation until a converged solution has been achieved
2. Restart the calculation with the same values just calculated
3. Watch it diverge
without re-starting the software or anything else, just click on
the button. For this to happen, there has to be a recycle stream.
I did mention bizarre.
(Probably something to do with the way runs the different
blocks sequentially).
Post by Lynn McGuire
Once converged is always converged in our software.
Good for you, then. Maybe this is a sentence you could put in
your brochure. People who've had experience of the phenomenon I
described will appreciate it, and people who don't will just take
it as given.
Wow, that is bizarre.

Recycle stream guesses are very important in any chemical process
simulator. But unless they are determining the flowrate of a closed
loop, they are just guesses and will be over-written by the calculated
values.

Lynn
Dorothy J Heydt
2020-05-21 19:46:57 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Conceivably, for the same reason UNIX used abbreviations for
commands whenever possible ... because the developers were
working on *teletypes* (or so I'm told) which were accordingly
slower than molasses, and a keystroke saved was a keystroke
earned?
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Jibini Kula Tumbili Kujisalimisha
2020-05-21 20:15:27 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my
calculation engine was written in Fortran II back in the
middle 1960s. I have entire subroutines with only one letter
variables names. X = liquid flowrates, Y = vapor flowrates, T
= temperature, P = pressure, I = general index, J =
supplemental index, K = supplemental supplemental index, A =
calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Conceivably, for the same reason UNIX used abbreviations for
commands whenever possible ... because the developers were
working on *teletypes* (or so I'm told) which were accordingly
slower than molasses, and a keystroke saved was a keystroke
earned?
I suspect it had more to do with punch cards, and the limitations
thereof. But I could be wrong. Just because it's never happened
before doesn't mean it's not possible.
--
Terry Austin

Proof that Alan Baker is a liar and a fool, and even stupider than
Lynn:
https://www.cbp.gov/newsroom/stats/sw-border-migration
(May 2019 total for people arrested for entering the United States
illegally is over 132,000 for just the southwest border.)

Vacation photos from Iceland:
https://plus.google.com/u/0/collection/QaXQkB
Scott Lurndal
2020-05-24 17:23:22 UTC
Reply
Permalink
Post by Jibini Kula Tumbili Kujisalimisha
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my
calculation engine was written in Fortran II back in the
middle 1960s. I have entire subroutines with only one letter
variables names. X = liquid flowrates, Y = vapor flowrates, T
= temperature, P = pressure, I = general index, J =
supplemental index, K = supplemental supplemental index, A =
calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Conceivably, for the same reason UNIX used abbreviations for
commands whenever possible ... because the developers were
working on *teletypes* (or so I'm told) which were accordingly
slower than molasses, and a keystroke saved was a keystroke
earned?
I suspect it had more to do with punch cards, and the limitations
thereof. But I could be wrong. Just because it's never happened
before doesn't mean it's not possible.
I suspect it had far more to do with the limited amount of core
(main memory) in those days than the input mechanism (whether unit
record or interactive).
Lynn McGuire
2020-05-25 00:09:15 UTC
Reply
Permalink
Post by Scott Lurndal
Post by Jibini Kula Tumbili Kujisalimisha
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my
calculation engine was written in Fortran II back in the
middle 1960s. I have entire subroutines with only one letter
variables names. X = liquid flowrates, Y = vapor flowrates, T
= temperature, P = pressure, I = general index, J =
supplemental index, K = supplemental supplemental index, A =
calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Conceivably, for the same reason UNIX used abbreviations for
commands whenever possible ... because the developers were
working on *teletypes* (or so I'm told) which were accordingly
slower than molasses, and a keystroke saved was a keystroke
earned?
I suspect it had more to do with punch cards, and the limitations
thereof. But I could be wrong. Just because it's never happened
before doesn't mean it's not possible.
I suspect it had far more to do with the limited amount of core
(main memory) in those days than the input mechanism (whether unit
record or interactive).
Most programmers are terse by nature.

Lynn
Lynn McGuire
2020-05-21 21:09:33 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Conceivably, for the same reason UNIX used abbreviations for
commands whenever possible ... because the developers were
working on *teletypes* (or so I'm told) which were accordingly
slower than molasses, and a keystroke saved was a keystroke
earned?
We typed our programs using cards and card punches. Misspellings were
to be avoided at all cost since you threw away the card and started over.

Lynn
Default User
2020-05-22 02:36:03 UTC
Reply
Permalink
Post by Lynn McGuire
We typed our programs using cards and card punches. Misspellings were
to be avoided at all cost since you threw away the card and started over.
FORTRAN was a required course for my BS degree, and we had to use punch cards. They were rough for guy like me. I'm a touch typists with decent speed but horrible accuracy. By the time I would get done punching up a program, I'd have a big stack of bad cards, and a small stack of cards not yet proven to be bad.

When I got done with that, I swore I would never do any programming again. Imagine my surprise when I became a software engineer. But I blame Zork for that.


Brian
Alan Baker
2020-05-22 02:49:15 UTC
Reply
Permalink
Post by Default User
Post by Lynn McGuire
We typed our programs using cards and card punches. Misspellings
were to be avoided at all cost since you threw away the card and
started over.
FORTRAN was a required course for my BS degree, and we had to use
punch cards. They were rough for guy like me. I'm a touch typists
with decent speed but horrible accuracy. By the time I would get done
punching up a program, I'd have a big stack of bad cards, and a small
stack of cards not yet proven to be bad.
When I got done with that, I swore I would never do any programming
again. Imagine my surprise when I became a software engineer. But I
blame Zork for that.
When my mother got divorced and needed a job, her only somewhat
marketable skill was that she could type, and so got a job as a keypunch
operator at the University of Toronto.

Programmers soon learned they wanted Mum to input their code, because
not only did she make fewer errors...

...she'd actually correct the errors of logic she saw in the
hand-written code she was given.

She literally learned to program by reading the programs she was
keypunching, and once management caught on, she quickly moved into a
better job.

:-)
Moriarty
2020-05-22 02:49:42 UTC
Reply
Permalink
Post by Default User
Post by Lynn McGuire
We typed our programs using cards and card punches. Misspellings were
to be avoided at all cost since you threw away the card and started over.
FORTRAN was a required course for my BS degree, and we had to use punch cards. They were rough for guy like me. I'm a touch typists with decent speed but horrible accuracy. By the time I would get done punching up a program, I'd have a big stack of bad cards, and a small stack of cards not yet proven to be bad.
When I got done with that, I swore I would never do any programming again. Imagine my surprise when I became a software engineer. But I blame Zork for that.
Ah, Zork! The first computer game I ever bought (1984, C64). I spent hours playing that thing before eventually finishing it, unassisted. Fortunately by then I had already started Zorks 2 and 3, and also Enchanter, Sorcerer and Starcross.

I still play them every so often.

-Moriarty
Default User
2020-05-23 02:09:48 UTC
Reply
Permalink
Post by Moriarty
Post by Default User
When I got done with that, I swore I would never do any programming again. Imagine my surprise when I became a software engineer. But I blame Zork for that.
Ah, Zork! The first computer game I ever bought (1984, C64). I spent hours playing that thing before eventually finishing it, unassisted. Fortunately by then I had already started Zorks 2 and 3, and also Enchanter, Sorcerer and Starcross.
I played pretty much the entire Infocom lineup, and some others like Amnesia. Then I got the itch to make my own game. I started using Hypertalk on the Mac, but that had limitations due to the interpreted nature and hardware of the day.

I started again in C, using the scripts as pseudo-code and the importing the text. I still have the game I made. The original code had some problems. I've done a few passes to improve things over the years.


Brian
Peter Trei
2020-05-22 02:20:12 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Conceivably, for the same reason UNIX used abbreviations for
commands whenever possible ... because the developers were
working on *teletypes* (or so I'm told) which were accordingly
slower than molasses, and a keystroke saved was a keystroke
earned?)
The first system I learned to program on (a DEC PDP-8/e, circa 1971)
had so little storage that when programming in BASIC, you rapidly learned
to use 1 and 2 character variable names, simply to cram more program in.

pt
Paul S Person
2020-05-22 16:49:22 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
Conceivably, for the same reason UNIX used abbreviations for
commands whenever possible ... because the developers were
working on *teletypes* (or so I'm told) which were accordingly
slower than molasses, and a keystroke saved was a keystroke
earned?
I used teletypes in the Army ... the main problem was that the
keyboard was different from that of a typewriter. Once you got used to
it, it was fast enough.

OTOH, three-letter abbreviations, some offical, some less so, were
used.
--
"I begin to envy Petronius."
"I have envied him long since."
h***@gmail.com
2020-05-22 02:53:56 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
As I recall if from the thermodynamics and fluid mechanics courses I took in the 90s at lease some of those are standard symbols for the properties
So it does make sense to use them
Thomas Koenig
2020-05-22 06:53:02 UTC
Reply
Permalink
Post by h***@gmail.com
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
As I recall if from the thermodynamics and fluid mechanics courses
I took in the 90s at lease some of those are standard symbols for
the properties
If your calculation has only one liquid flow rate, one vapor flow
rate, one temperature and one pressure, and nothing for enthalpy,
entropy, vapor pressure of pure and mixed substances, composition,
what you can actually calculate is limited indeed.

I would at least have expected something along the lines of TIN, TOUT,
XMIX, etc... or how many calculations did you do at did not involve
any indices on the properties?
Lynn McGuire
2020-05-22 18:47:15 UTC
Reply
Permalink
Post by Thomas Koenig
Post by h***@gmail.com
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
As I recall if from the thermodynamics and fluid mechanics courses
I took in the 90s at lease some of those are standard symbols for
the properties
If your calculation has only one liquid flow rate, one vapor flow
rate, one temperature and one pressure, and nothing for enthalpy,
entropy, vapor pressure of pure and mixed substances, composition,
what you can actually calculate is limited indeed.
I would at least have expected something along the lines of TIN, TOUT,
XMIX, etc... or how many calculations did you do at did not involve
any indices on the properties?
700,000 lines of Fortran 77 code. 5,000 subroutines and functions.
10,000 lines of C and C++ code.

The one character variables are mostly from the 1960s through the 1990s.
Now I have variable names like

common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time

C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time

Lynn
William Hyde
2020-05-22 20:00:52 UTC
Reply
Permalink
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.

I've spent thousands of hours debugging or modifying code with mysterious undocumented variable names. Some was old, but some was by an excellent (in all other respects) programmer who used random variable names (temperature might be "vpm" for some reason that made sense to him) and had apparently sworn a blood oath never to write a useful comment statement".

In one case I had to go back to the original mathematics, recast in in a form suitable for programming, then scan the program for patterns that looked like my mathematics.

I was going to complain about using punched cards, but my supervisor at NASA started at Oak Ridge using punched tape. You had a certain block of real time assigned to you in which to run your tape. If the program crashed you had two minutes to fix it. Otherwise the rest of your time went to a line of people who were waiting with their own tapes for such an opportunity.

Computer cards were extremely useful when directing chess tournaments, and I always had a good supply of rejected cards. I suppose directors have to actually buy materials now.

William Hyde
Paul S Person
2020-05-23 16:56:26 UTC
Reply
Permalink
On Fri, 22 May 2020 13:00:52 -0700 (PDT), William Hyde
Post by William Hyde
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.
I've spent thousands of hours debugging or modifying code with mysterious undocumented variable names. Some was old, but some was by an excellent (in all other respects) programmer who used random variable names (temperature might be "vpm" for some reason that made sense to him) and had apparently sworn a blood oath never to write a useful comment statement".
A lot of programming professionals seem to feel the same way.
Post by William Hyde
In one case I had to go back to the original mathematics, recast in in a form suitable for programming, then scan the program for patterns that looked like my mathematics.
I was going to complain about using punched cards, but my supervisor at NASA started at Oak Ridge using punched tape. You had a certain block of real time assigned to you in which to run your tape. If the program crashed you had two minutes to fix it. Otherwise the rest of your time went to a line of people who were waiting with their own tapes for such an opportunity.
Computer cards were extremely useful when directing chess tournaments, and I always had a good supply of rejected cards. I suppose directors have to actually buy materials now.
William Hyde
--
"I begin to envy Petronius."
"I have envied him long since."
Dorothy J Heydt
2020-05-23 17:22:09 UTC
Reply
Permalink
Post by Paul S Person
On Fri, 22 May 2020 13:00:52 -0700 (PDT), William Hyde
Post by William Hyde
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.
I've spent thousands of hours debugging or modifying code with
mysterious undocumented variable names. Some was old, but some was by
an excellent (in all other respects) programmer who used random variable
names (temperature might be "vpm" for some reason that made sense to
him) and had apparently sworn a blood oath never to write a useful
comment statement".
A lot of programming professionals seem to feel the same way.
Post by William Hyde
In one case I had to go back to the original mathematics, recast in in
a form suitable for programming, then scan the program for patterns that
looked like my mathematics.
I asked Hal if he wanted to comment on commenting, and he said,
"No, because if you're doing maintenance on a program you can't
trust the comments anyway."

I will comment that Hal always comments his code lavishly and
intelligibly. I haven't looked at any of his programs except the
one for "crontab," which runs our classical-music feed on a
Raspberry Pi, and every single line of code has a comment
explaining what it does and, if necessary, how to change it.

But then he knows the end user, me, doesn't know beans about
code.

Somewhere in _A Point of Honor_ the programmer Greg Hampton speaks
of a bit of code that runs a riding horse in VR. It has a bug in
it, they've known about the bug for years and they've always told
the users (who are going to ride the horse), "Don't do *this* or
it'll hang." This has been adequate for some time, until an
ingenious user finds a new way the bug can work, at which point
Greg says, "I commented that code, and when I have time to fix
that bug, I'll comment the fix too."
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Lynn McGuire
2020-05-23 22:43:17 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Paul S Person
On Fri, 22 May 2020 13:00:52 -0700 (PDT), William Hyde
Post by William Hyde
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.
I've spent thousands of hours debugging or modifying code with
mysterious undocumented variable names. Some was old, but some was by
an excellent (in all other respects) programmer who used random variable
names (temperature might be "vpm" for some reason that made sense to
him) and had apparently sworn a blood oath never to write a useful
comment statement".
A lot of programming professionals seem to feel the same way.
Post by William Hyde
In one case I had to go back to the original mathematics, recast in in
a form suitable for programming, then scan the program for patterns that
looked like my mathematics.
I asked Hal if he wanted to comment on commenting, and he said,
"No, because if you're doing maintenance on a program you can't
trust the comments anyway."
I will comment that Hal always comments his code lavishly and
intelligibly. I haven't looked at any of his programs except the
one for "crontab," which runs our classical-music feed on a
Raspberry Pi, and every single line of code has a comment
explaining what it does and, if necessary, how to change it.
But then he knows the end user, me, doesn't know beans about
code.
Somewhere in _A Point of Honor_ the programmer Greg Hampton speaks
of a bit of code that runs a riding horse in VR. It has a bug in
it, they've known about the bug for years and they've always told
the users (who are going to ride the horse), "Don't do *this* or
it'll hang." This has been adequate for some time, until an
ingenious user finds a new way the bug can work, at which point
Greg says, "I commented that code, and when I have time to fix
that bug, I'll comment the fix too."
Hal is wise man. The first thing one does when you see a comment is to
validate the comment.

My favorite is when there are 2 or more comments and they are
contradictory. And, I was the author of both comments !

Lynn
Dorothy J Heydt
2020-05-24 00:12:26 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Paul S Person
On Fri, 22 May 2020 13:00:52 -0700 (PDT), William Hyde
Post by William Hyde
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.
I've spent thousands of hours debugging or modifying code with
mysterious undocumented variable names. Some was old, but some was by
an excellent (in all other respects) programmer who used random variable
names (temperature might be "vpm" for some reason that made sense to
him) and had apparently sworn a blood oath never to write a useful
comment statement".
A lot of programming professionals seem to feel the same way.
Post by William Hyde
In one case I had to go back to the original mathematics, recast in in
a form suitable for programming, then scan the program for patterns that
looked like my mathematics.
I asked Hal if he wanted to comment on commenting, and he said,
"No, because if you're doing maintenance on a program you can't
trust the comments anyway."
I will comment that Hal always comments his code lavishly and
intelligibly. I haven't looked at any of his programs except the
one for "crontab," which runs our classical-music feed on a
Raspberry Pi, and every single line of code has a comment
explaining what it does and, if necessary, how to change it.
But then he knows the end user, me, doesn't know beans about
code.
Somewhere in _A Point of Honor_ the programmer Greg Hampton speaks
of a bit of code that runs a riding horse in VR. It has a bug in
it, they've known about the bug for years and they've always told
the users (who are going to ride the horse), "Don't do *this* or
it'll hang." This has been adequate for some time, until an
ingenious user finds a new way the bug can work, at which point
Greg says, "I commented that code, and when I have time to fix
that bug, I'll comment the fix too."
Hal is wise man. The first thing one does when you see a comment is to
validate the comment.
My favorite is when there are 2 or more comments and they are
contradictory. And, I was the author of both comments !
What did you do to reconcile them? Flip a coin?
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Kevrob
2020-05-24 00:30:53 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Paul S Person
On Fri, 22 May 2020 13:00:52 -0700 (PDT), William Hyde
Post by William Hyde
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.
I've spent thousands of hours debugging or modifying code with
mysterious undocumented variable names. Some was old, but some was by
an excellent (in all other respects) programmer who used random variable
names (temperature might be "vpm" for some reason that made sense to
him) and had apparently sworn a blood oath never to write a useful
comment statement".
A lot of programming professionals seem to feel the same way.
Post by William Hyde
In one case I had to go back to the original mathematics, recast in in
a form suitable for programming, then scan the program for patterns that
looked like my mathematics.
I asked Hal if he wanted to comment on commenting, and he said,
"No, because if you're doing maintenance on a program you can't
trust the comments anyway."
I will comment that Hal always comments his code lavishly and
intelligibly. I haven't looked at any of his programs except the
one for "crontab," which runs our classical-music feed on a
Raspberry Pi, and every single line of code has a comment
explaining what it does and, if necessary, how to change it.
But then he knows the end user, me, doesn't know beans about
code.
Somewhere in _A Point of Honor_ the programmer Greg Hampton speaks
of a bit of code that runs a riding horse in VR. It has a bug in
it, they've known about the bug for years and they've always told
the users (who are going to ride the horse), "Don't do *this* or
it'll hang." This has been adequate for some time, until an
ingenious user finds a new way the bug can work, at which point
Greg says, "I commented that code, and when I have time to fix
that bug, I'll comment the fix too."
Hal is wise man. The first thing one does when you see a comment is to
validate the comment.
My favorite is when there are 2 or more comments and they are
contradictory. And, I was the author of both comments !
What did you do to reconcile them? Flip a coin?
--
Add a third comment, of course! :)

Kevin R
Paul S Person
2020-05-24 16:38:28 UTC
Reply
Permalink
<snippo>
Post by Dorothy J Heydt
Post by Lynn McGuire
Hal is wise man. The first thing one does when you see a comment is to
validate the comment.
My favorite is when there are 2 or more comments and they are
contradictory. And, I was the author of both comments !
What did you do to reconcile them? Flip a coin?
Ideally, you figure out what the code actually /does/ and replace both
comments with a new one -- a new one which describes what the code
actually does, not just any new comment.
--
"I begin to envy Petronius."
"I have envied him long since."
Robert Carnegie
2020-05-24 19:28:23 UTC
Reply
Permalink
Post by Paul S Person
<snippo>
Post by Dorothy J Heydt
Post by Lynn McGuire
Hal is wise man. The first thing one does when you see a comment is to
validate the comment.
My favorite is when there are 2 or more comments and they are
contradictory. And, I was the author of both comments !
What did you do to reconcile them? Flip a coin?
Ideally, you figure out what the code actually /does/ and replace both
comments with a new one -- a new one which describes what the code
actually does, not just any new comment.
But at this point you probably want to change
what the program does. Though sometimes it turns out
to do just what you wanted.

I try to document each block (paragraph) of a program
to say what it's supposed to achieve. If it uses a
sneaky technique, then I try to explain the output
and maybe the method. For instance: the school "year"
starts some time in August; so, for the year number
corresponding to a date, subtract 7 months then take
the calendar year of the result; between July or
August 2020, that is 2019 and 2020. I expect it
also to be reasonably obvious, in context, why the
program wants to know that.

Whether a previous author's comments survive in my
version of a program depends a lot on how much of
the previous program survives. I have done merciless
rewrites. But the previous comments may have
sentimental value...
Lynn McGuire
2020-05-25 00:14:26 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Paul S Person
On Fri, 22 May 2020 13:00:52 -0700 (PDT), William Hyde
Post by William Hyde
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.
I've spent thousands of hours debugging or modifying code with
mysterious undocumented variable names. Some was old, but some was by
an excellent (in all other respects) programmer who used random variable
names (temperature might be "vpm" for some reason that made sense to
him) and had apparently sworn a blood oath never to write a useful
comment statement".
A lot of programming professionals seem to feel the same way.
Post by William Hyde
In one case I had to go back to the original mathematics, recast in in
a form suitable for programming, then scan the program for patterns that
looked like my mathematics.
I asked Hal if he wanted to comment on commenting, and he said,
"No, because if you're doing maintenance on a program you can't
trust the comments anyway."
I will comment that Hal always comments his code lavishly and
intelligibly. I haven't looked at any of his programs except the
one for "crontab," which runs our classical-music feed on a
Raspberry Pi, and every single line of code has a comment
explaining what it does and, if necessary, how to change it.
But then he knows the end user, me, doesn't know beans about
code.
Somewhere in _A Point of Honor_ the programmer Greg Hampton speaks
of a bit of code that runs a riding horse in VR. It has a bug in
it, they've known about the bug for years and they've always told
the users (who are going to ride the horse), "Don't do *this* or
it'll hang." This has been adequate for some time, until an
ingenious user finds a new way the bug can work, at which point
Greg says, "I commented that code, and when I have time to fix
that bug, I'll comment the fix too."
Hal is wise man. The first thing one does when you see a comment is to
validate the comment.
My favorite is when there are 2 or more comments and they are
contradictory. And, I was the author of both comments !
What did you do to reconcile them? Flip a coin?
Research. No coin flips allowed. If I cannot figure out what is going
on then I go get one of me mates and we figure it out together.

Lynn
William Hyde
2020-05-24 19:28:06 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Paul S Person
On Fri, 22 May 2020 13:00:52 -0700 (PDT), William Hyde
Post by William Hyde
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.
I've spent thousands of hours debugging or modifying code with
mysterious undocumented variable names. Some was old, but some was by
an excellent (in all other respects) programmer who used random variable
names (temperature might be "vpm" for some reason that made sense to
him) and had apparently sworn a blood oath never to write a useful
comment statement".
A lot of programming professionals seem to feel the same way.
Post by William Hyde
In one case I had to go back to the original mathematics, recast in in
a form suitable for programming, then scan the program for patterns that
looked like my mathematics.
I asked Hal if he wanted to comment on commenting, and he said,
"No, because if you're doing maintenance on a program you can't
trust the comments anyway."
I will comment that Hal always comments his code lavishly and
intelligibly. I haven't looked at any of his programs except the
one for "crontab," which runs our classical-music feed on a
Raspberry Pi, and every single line of code has a comment
explaining what it does and, if necessary, how to change it.
But then he knows the end user, me, doesn't know beans about
code.
Somewhere in _A Point of Honor_ the programmer Greg Hampton speaks
of a bit of code that runs a riding horse in VR. It has a bug in
it, they've known about the bug for years and they've always told
the users (who are going to ride the horse), "Don't do *this* or
it'll hang." This has been adequate for some time, until an
ingenious user finds a new way the bug can work, at which point
Greg says, "I commented that code, and when I have time to fix
that bug, I'll comment the fix too."
Hal is wise man. The first thing one does when you see a comment is to
validate the comment.
My favorite is when there are 2 or more comments and they are
contradictory. And, I was the author of both comments !
When in my youth I was writing uncommented programs because they were obvious,and only I would use them. I'd often have to return to the program a year later. Unable to figure out what I had done, I'd rewrite the program, generally producing a clone of the original.

I only had to to do this ten times or so before I began to put in comments even on programs that only I would use. Fast learner, that's me.

William Hyde
Lynn McGuire
2020-05-25 00:18:29 UTC
Reply
Permalink
Post by William Hyde
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Paul S Person
On Fri, 22 May 2020 13:00:52 -0700 (PDT), William Hyde
Post by William Hyde
Post by Lynn McGuire
Now I have variable names like
common / globalTimeSettings / current_simulation_time,
* maximum_simulation_time,
* simulation_time_step,
* last_simulation_time,
* next_simulation_time
C current time in hours
double precision current_simulation_time
C the last current time in hours
double precision last_simulation_time
C maximum time in hours
double precision maximum_simulation_time
C time step in hours
double precision simulation_time_step
C the next time step in hours
double precision next_simulation_time
A pleasure to read.
I've spent thousands of hours debugging or modifying code with
mysterious undocumented variable names. Some was old, but some was by
an excellent (in all other respects) programmer who used random variable
names (temperature might be "vpm" for some reason that made sense to
him) and had apparently sworn a blood oath never to write a useful
comment statement".
A lot of programming professionals seem to feel the same way.
Post by William Hyde
In one case I had to go back to the original mathematics, recast in in
a form suitable for programming, then scan the program for patterns that
looked like my mathematics.
I asked Hal if he wanted to comment on commenting, and he said,
"No, because if you're doing maintenance on a program you can't
trust the comments anyway."
I will comment that Hal always comments his code lavishly and
intelligibly. I haven't looked at any of his programs except the
one for "crontab," which runs our classical-music feed on a
Raspberry Pi, and every single line of code has a comment
explaining what it does and, if necessary, how to change it.
But then he knows the end user, me, doesn't know beans about
code.
Somewhere in _A Point of Honor_ the programmer Greg Hampton speaks
of a bit of code that runs a riding horse in VR. It has a bug in
it, they've known about the bug for years and they've always told
the users (who are going to ride the horse), "Don't do *this* or
it'll hang." This has been adequate for some time, until an
ingenious user finds a new way the bug can work, at which point
Greg says, "I commented that code, and when I have time to fix
that bug, I'll comment the fix too."
Hal is wise man. The first thing one does when you see a comment is to
validate the comment.
My favorite is when there are 2 or more comments and they are
contradictory. And, I was the author of both comments !
When in my youth I was writing uncommented programs because they were obvious,and only I would use them. I'd often have to return to the program a year later. Unable to figure out what I had done, I'd rewrite the program, generally producing a clone of the original.
I only had to to do this ten times or so before I began to put in comments even on programs that only I would use. Fast learner, that's me.
William Hyde
In my youth, the software was store on disk drums. Each line cost us
money per day. So we did not have any comment lines whatsoever. Not
until we got a Prime 450 in 1976 ? with our own disk drive (a 300 ??? MB
12 inch diameter ten platter drive).

Lynn
Paul S Person
2020-05-22 16:43:40 UTC
Reply
Permalink
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
--
"I begin to envy Petronius."
"I have envied him long since."
Dorothy J Heydt
2020-05-22 19:36:36 UTC
Reply
Permalink
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
Even if we're trying to persuade the purchasing department of the
end-users that It Can Be Done. (I never wrote a line of COBOL,
but Hal made his living off it for forty years.)
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Default User
2020-05-23 02:11:25 UTC
Reply
Permalink
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."


Brian
Dorothy J Heydt
2020-05-23 02:55:17 UTC
Reply
Permalink
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
We have a refrigerator magnet that says that, prefaced by "REAL
Programmers don't document."
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Jerry Brown
2020-05-23 07:21:15 UTC
Reply
Permalink
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
I'm convinced that the motto of my predecessor must have been
"Commenting code is giving infomation to the enemy".
--
Jerry Brown

A cat may look at a king
(but probably won't bother)
Thomas Koenig
2020-05-23 11:28:35 UTC
Reply
Permalink
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
I'm convinced that the motto of my predecessor must have been
"Commenting code is giving infomation to the enemy".
Why? In old code, I've seen stuff like

C Increment the value of I
I = I + 1

but nothing about global variables used, assumptions on entering
a subroutine, ... etc.
Jaimie Vandenbergh
2020-05-23 12:53:22 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
I'm convinced that the motto of my predecessor must have been
"Commenting code is giving infomation to the enemy".
Why? In old code, I've seen stuff like
C Increment the value of I
I = I + 1
but nothing about global variables used, assumptions on entering
a subroutine, ... etc.
Mad, isn't it? The sort of programmer who has to be 'encouraged' to comment
tends to be the type who'll do that as a passive aggressive protest. There's a
bit less of that in these days of enforced peer review on code checkins, but
it's definitely not a lost art.

Comments should explain *why* it's done like this. The code explains how it's
done, in most cases (see the Obfuscated C competition for notable
non-exemplars).

Cheers - Jaimie
--
Is everyone acting like a solipsist in here, or is it just me?
Dorothy J Heydt
2020-05-23 15:47:07 UTC
Reply
Permalink
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
I'm convinced that the motto of my predecessor must have been
"Commenting code is giving infomation to the enemy".
Hal says, "I remember commenting one section of code to the effect
of 'Do not mess with this section of code unless you understand
what it is doing.'"
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Torbjorn Lindgren
2020-05-23 20:42:25 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Jerry Brown
I'm convinced that the motto of my predecessor must have been
"Commenting code is giving infomation to the enemy".
Hal says, "I remember commenting one section of code to the effect
of 'Do not mess with this section of code unless you understand
what it is doing.'"
Sixth Edition UNIX source code famously contained a comment saying
"You are Not Expected to Understand This" [1].

There were helpful comments above this, it was basically a combination
of "this is more subtle than it appears" and "this won't be on the
exam" [2].

The famous Lions book (UNIX v6 source code with comments) explains
exactly what and how the code works (it explains all the ~9000 source
code lines).

IIRC the original code only worked due very specific properties on the
PDP-11 C compiler but this was before UNIX ran on anything other than
a few specific PDP-11 models they had in their lab, it had to be
rewritten for v7 which could run on more hardware.

1. https://thenewstack.io/not-expected-understand-explainer/
2. https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code#%22You_are_not_expected_to_understand_this%22
Gary R. Schmidt
2020-05-24 05:08:45 UTC
Reply
Permalink
Post by Torbjorn Lindgren
Post by Dorothy J Heydt
Post by Jerry Brown
I'm convinced that the motto of my predecessor must have been
"Commenting code is giving infomation to the enemy".
Hal says, "I remember commenting one section of code to the effect
of 'Do not mess with this section of code unless you understand
what it is doing.'"
Sixth Edition UNIX source code famously contained a comment saying
"You are Not Expected to Understand This" [1].
There were helpful comments above this, it was basically a combination
of "this is more subtle than it appears" and "this won't be on the
exam" [2].
The famous Lions book (UNIX v6 source code with comments) explains
exactly what and how the code works (it explains all the ~9000 source
code lines).
IIRC the original code only worked due very specific properties on the
PDP-11 C compiler but this was before UNIX ran on anything other than
a few specific PDP-11 models they had in their lab, it had to be
rewritten for v7 which could run on more hardware.
1. https://thenewstack.io/not-expected-understand-explainer/
2. https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code#%22You_are_not_expected_to_understand_this%22
I wish I still had my copy of Lions, but it got rained on... (It was
one of the multitude that were just photocopies :-) )

Cheers,
Gary B-)
--
Waiting for a new signature to suggest itself...
Paul S Person
2020-05-23 16:59:47 UTC
Reply
Permalink
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
--
"I begin to envy Petronius."
"I have envied him long since."
Dorothy J Heydt
2020-05-23 17:24:26 UTC
Reply
Permalink
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
J. Clarke
2020-05-23 18:35:18 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
That is not really all that unusual. We have a guy at work whose
command of Fortran and C greatly exceeds his grasp of English. It
doesn't exceed his grasp of Chinese, mind you, but comments in Chinese
aren't a great deal of help to the rest of us.
Dorothy J Heydt
2020-05-23 20:16:46 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation
final result.
Post by Dorothy J Heydt
Post by Jerry Brown
Post by Default User
Post by Paul S Person
Post by Thomas Koenig
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
That is not really all that unusual. We have a guy at work whose
command of Fortran and C greatly exceeds his grasp of English. It
doesn't exceed his grasp of Chinese, mind you, but comments in Chinese
aren't a great deal of help to the rest of us.
Right. And if his programs work, perhaps it doesn't matter. So
long as you've got somebody in the shop who can look at the code
and figure it out without comments.
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
J. Clarke
2020-05-23 22:13:20 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation
final result.
Post by Dorothy J Heydt
Post by Jerry Brown
Post by Default User
Post by Paul S Person
Post by Thomas Koenig
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
That is not really all that unusual. We have a guy at work whose
command of Fortran and C greatly exceeds his grasp of English. It
doesn't exceed his grasp of Chinese, mind you, but comments in Chinese
aren't a great deal of help to the rest of us.
Right. And if his programs work, perhaps it doesn't matter. So
long as you've got somebody in the shop who can look at the code
and figure it out without comments.
Actually it is a bit of a problem because guess who has to do code
review on his stuff.
Dorothy J Heydt
2020-05-23 22:47:33 UTC
Reply
Permalink
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my
calculation
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Jerry Brown
Post by Default User
Post by Paul S Person
Post by Thomas Koenig
Post by Lynn McGuire
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation
final result.
Post by Dorothy J Heydt
Post by Jerry Brown
Post by Default User
Post by Paul S Person
Post by Thomas Koenig
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
That is not really all that unusual. We have a guy at work whose
command of Fortran and C greatly exceeds his grasp of English. It
doesn't exceed his grasp of Chinese, mind you, but comments in Chinese
aren't a great deal of help to the rest of us.
Right. And if his programs work, perhaps it doesn't matter. So
long as you've got somebody in the shop who can look at the code
and figure it out without comments.
Actually it is a bit of a problem because guess who has to do code
review on his stuff.
Well, I hope and trust you're really good at it.
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
J. Clarke
2020-05-24 01:40:46 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my
calculation
Post by Dorothy J Heydt
Post by Lynn McGuire
Post by Dorothy J Heydt
Post by Jerry Brown
Post by Default User
Post by Paul S Person
Post by Thomas Koenig
Post by Lynn McGuire
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation
final result.
Post by Dorothy J Heydt
Post by Jerry Brown
Post by Default User
Post by Paul S Person
Post by Thomas Koenig
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
That is not really all that unusual. We have a guy at work whose
command of Fortran and C greatly exceeds his grasp of English. It
doesn't exceed his grasp of Chinese, mind you, but comments in Chinese
aren't a great deal of help to the rest of us.
Right. And if his programs work, perhaps it doesn't matter. So
long as you've got somebody in the shop who can look at the code
and figure it out without comments.
Actually it is a bit of a problem because guess who has to do code
review on his stuff.
Well, I hope and trust you're really good at it.
Between us we are. We have a system-we check the Fortran and C code
agains APL code written by a different programmer. If the results
match and seem reasonable we're happy. If they don't then we have to
figure out why.
Dimensional Traveler
2020-05-23 19:55:47 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
--
<to be filled in at a later date>
Gary R. Schmidt
2020-05-24 05:06:47 UTC
Reply
Permalink
Post by Dimensional Traveler
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
     https://xkcd.com/2309/
I say that we tar and feather Cueball.  The base code of my
calculation
engine was written in Fortran II back in the middle 1960s.  I have
entire subroutines with only one letter variables names.  X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment?  Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.

And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."

Sigh.

Cheers,
Gary B-)
--
Waiting for a new signature to suggest itself...
h***@gmail.com
2020-05-24 05:43:47 UTC
Reply
Permalink
Post by Gary R. Schmidt
Post by Dimensional Traveler
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.
And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."
The worst story I've heard for this was a piece of code being ported between 2 different sets of hardware
The first always allocated memory in a particular way, the second almost always did
Deep down in the dark, mysterious parts of the program there was a retrieval which retrieved 2 bits of information and depended on the way it was allocated.
Then it was used much higher up the call-stack
Which resulted in the system getting things horribly wrong a few times a month on the new hardware...
iirc it took somebody a solid month or two of digging to find that one
Thomas Koenig
2020-05-24 06:54:19 UTC
Reply
Permalink
Post by Gary R. Schmidt
Post by Dimensional Traveler
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.
And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."
Alternatively, it may have been written by Melvin Kaye.

http://www.cs.utah.edu/~elb/folklore/mel.html
Gary R. Schmidt
2020-05-24 11:26:13 UTC
Reply
Permalink
Post by Thomas Koenig
Post by Gary R. Schmidt
Post by Dimensional Traveler
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.
And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."
Alternatively, it may have been written by Melvin Kaye.
http://www.cs.utah.edu/~elb/folklore/mel.html
Longago I worked with people who reminisced about using these tricks on
revolving drums, and one who claimed he had a similar technique for
mercury baths taught me at $GOSHWHATTAUNIVERSITY...

Cheers,
Gary B-)
--
Waiting for a new signature to suggest itself...
P. Taine
2020-05-24 21:00:02 UTC
Reply
Permalink
Post by Gary R. Schmidt
Post by Thomas Koenig
Post by Gary R. Schmidt
Post by Dimensional Traveler
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.
And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."
Alternatively, it may have been written by Melvin Kaye.
http://www.cs.utah.edu/~elb/folklore/mel.html
Longago I worked with people who reminisced about using these tricks on
revolving drums, and one who claimed he had a similar technique for
mercury baths taught me at $GOSHWHATTAUNIVERSITY...
Cheers,
Gary B-)
P. Taine
2020-05-24 21:55:06 UTC
Reply
Permalink
Sorry about that. I had never tried that and didn't realize how badly it would
not work.

Image of a button reading "Real men write self-modifying code".

(along with Symbolics button "We do windows".)

P. Taine
J. Clarke
2020-05-24 22:44:02 UTC
Reply
Permalink
Post by P. Taine
Sorry about that. I had never tried that and didn't realize how badly it would
not work.
Image of a button reading "Real men write self-modifying code".
I plead guilty. Not an ideal approach to problems but sometimes it's
easier than rewriting the whole mess.
Post by P. Taine
(along with Symbolics button "We do windows".)
P. Taine
Peter Trei
2020-05-24 23:02:02 UTC
Reply
Permalink
Post by J. Clarke
Post by P. Taine
Sorry about that. I had never tried that and didn't realize how badly it would
not work.
Image of a button reading "Real men write self-modifying code".
I plead guilty. Not an ideal approach to problems but sometimes it's
easier than rewriting the whole mess.
Post by P. Taine
(along with Symbolics button "We do windows".)
BTDT, had Nancy make the button. :-)

Seriously, the last time I recall seriously doing this was in some 6502 assembler. IIRC, I wanted to extend the range of some autoimdexing instructions by overwriting the base address.

Pt
Dimensional Traveler
2020-05-24 07:17:46 UTC
Reply
Permalink
Post by Gary R. Schmidt
Post by Dimensional Traveler
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
     https://xkcd.com/2309/
I say that we tar and feather Cueball.  The base code of my
calculation
engine was written in Fortran II back in the middle 1960s.  I have
entire subroutines with only one letter variables names.  X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental
supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment?  Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.
And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."
Another reason is because most programmers can't explain anything in
words that anyone but a few other programmers can understand. Its
writing documentation and doing that is a skill and/or knack that most
people don't have. Human nature being what it is, this leads back to
"But then a /non-programmer/ might be able to understand the program,
and We Can't Have That." and "It was hard to write. It should be hard to
read."
--
<to be filled in at a later date>
J. Clarke
2020-05-24 10:50:33 UTC
Reply
Permalink
On Sun, 24 May 2020 00:17:46 -0700, Dimensional Traveler
Post by Dimensional Traveler
Post by Gary R. Schmidt
Post by Dimensional Traveler
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
     https://xkcd.com/2309/
I say that we tar and feather Cueball.  The base code of my
calculation
engine was written in Fortran II back in the middle 1960s.  I have
entire subroutines with only one letter variables names.  X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment?  Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.
And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."
Another reason is because most programmers can't explain anything in
words that anyone but a few other programmers can understand. Its
writing documentation and doing that is a skill and/or knack that most
people don't have. Human nature being what it is, this leads back to
"But then a /non-programmer/ might be able to understand the program,
and We Can't Have That." and "It was hard to write. It should be hard to
read."
If they tried at all it would help.

I think that part of the problem is that people get the idea that
comments are supposed to explain things that are clear from the
code--there is no need to say "This is a loop". There is a need to
say "The Bisector Method was used here because the deadline against
which we were working was too tight to allow us to implement and test
anything more complex--please feel free to improve it" or "The
Bisector Method was chosen here because it was necessary to use a
method that could easily be explained to a lawyer--please do not
change it without running the proposed change by legal" or "The
Bisector Method was chosen here because it is specified by Federal
Regulation x-y-z that that method be used for this type of
calculation" or "The Bisector Method was used here because it's the
only method I know".

Even something as simple as "This function calculates actuarial
commutation functions as described in Bowers (1986)" can be a huge
help.

And then there's global variables. Don't get me started on global
variables.
Paul S Person
2020-05-24 16:53:19 UTC
Reply
Permalink
On Sun, 24 May 2020 00:17:46 -0700, Dimensional Traveler
Post by Dimensional Traveler
Post by Gary R. Schmidt
Post by Dimensional Traveler
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
     https://xkcd.com/2309/
I say that we tar and feather Cueball.  The base code of my
calculation
engine was written in Fortran II back in the middle 1960s.  I have
entire subroutines with only one letter variables names.  X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment?  Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.
And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."
Another reason is because most programmers can't explain anything in
words that anyone but a few other programmers can understand. Its
writing documentation and doing that is a skill and/or knack that most
people don't have. Human nature being what it is, this leads back to
"But then a /non-programmer/ might be able to understand the program,
and We Can't Have That." and "It was hard to write. It should be hard to
read."
That is similar to my theory about the problem with most user
documentation/help files:

the people who actually know how the program works have no idea at all
how a new user would approach it or what they would need to know

those who have an idea of what new users would need to know have no
idea how the program actually works, just how it was supposed to work
-- which may or may not be the same thing
--
"I begin to envy Petronius."
"I have envied him long since."
Dorothy J Heydt
2020-05-24 19:19:09 UTC
Reply
Permalink
Post by J. Clarke
On Sun, 24 May 2020 00:17:46 -0700, Dimensional Traveler
Post by Dimensional Traveler
Post by Gary R. Schmidt
Post by Dimensional Traveler
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
     https://xkcd.com/2309/
I say that we tar and feather Cueball.  The base code of my
calculation
engine was written in Fortran II back in the middle 1960s.  I have
entire subroutines with only one letter variables names.  X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment?  Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
Properly commenting code can take as long as writing or altering the
code and IME programmers are very often very pressed for time.
This, oh so frequently this.
And the managers who harried them onward then come to me and ask, "Why
can't anyone fix this?" and I say to them, "Because no-one knows what it
does, and how it does it."
Another reason is because most programmers can't explain anything in
words that anyone but a few other programmers can understand. Its
writing documentation and doing that is a skill and/or knack that most
people don't have. Human nature being what it is, this leads back to
"But then a /non-programmer/ might be able to understand the program,
and We Can't Have That." and "It was hard to write. It should be hard to
read."
That is similar to my theory about the problem with most user
the people who actually know how the program works have no idea at all
how a new user would approach it or what they would need to know
And/or they assume that everybody already knows it.

Or they assumed, when writing the documentation, that they had
put something entirely crucial, that they have known during the
whole development period, which in fact they didn't put in.

There was the time when the original Macintosh was about to come
out, and the Computer Center at UC Berkeley was sent one to test
out, along with its instruction book. I knew a smidgen about
computers (mostly BSD UNIX) and I knew how to write readable
text, so I volunteered to test it.

I could make it boot up (turn on the power), but I couldn't make
it do anything else. I called on my husband (he of the
decades-long experience in many systems and languages) for help,
and he couldn't make it speak either. There sat these icons on
the desktop, but we couldn't open them.

Then, quite by accident, I *double-clicked* on one of the icons
and it opened. Aha, we said, *that's* how you do it. Where in
the instruction does it say so?

So we read the instructions from cover to cover. Nowhere did it
say "to open a program, double-click on the appropriate icon."
Everybody at Apple had been opening icons by double-clicking for
Cat knows how many years, they allowed themselves to forget that
not everybody had been doing it.

So armed with that knowledge, I played around with the Mac for a
while, and reported back the things that I could live with and
the things I couldn't, and mentioned that there was nothing in
the text about double-clicking.

When the Mac actually launched (remember the "1984" commercial?)
I took a look at the instruction book and *now* it mentioned
double-clicking.
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Jerry Brown
2020-05-25 08:11:28 UTC
Reply
Permalink
On Sun, 24 May 2020 19:19:09 GMT, ***@kithrup.com (Dorothy J
Heydt) wrote:

<snip>
Post by Dorothy J Heydt
Post by Paul S Person
That is similar to my theory about the problem with most user
the people who actually know how the program works have no idea at all
how a new user would approach it or what they would need to know
And/or they assume that everybody already knows it.
Or they assumed, when writing the documentation, that they had
put something entirely crucial, that they have known during the
whole development period, which in fact they didn't put in.
There was the time when the original Macintosh was about to come
out, and the Computer Center at UC Berkeley was sent one to test
out, along with its instruction book. I knew a smidgen about
computers (mostly BSD UNIX) and I knew how to write readable
text, so I volunteered to test it.
I could make it boot up (turn on the power), but I couldn't make
it do anything else. I called on my husband (he of the
decades-long experience in many systems and languages) for help,
and he couldn't make it speak either. There sat these icons on
the desktop, but we couldn't open them.
Then, quite by accident, I *double-clicked* on one of the icons
and it opened. Aha, we said, *that's* how you do it. Where in
the instruction does it say so?
So we read the instructions from cover to cover. Nowhere did it
say "to open a program, double-click on the appropriate icon."
Everybody at Apple had been opening icons by double-clicking for
Cat knows how many years, they allowed themselves to forget that
not everybody had been doing it.
So armed with that knowledge, I played around with the Mac for a
while, and reported back the things that I could live with and
the things I couldn't, and mentioned that there was nothing in
the text about double-clicking.
When the Mac actually launched (remember the "1984" commercial?)
I took a look at the instruction book and *now* it mentioned
double-clicking.
There has always been a certain arrogance to Apple, both in its
creators and user base.

I remember an advert in the eighties highlighting how "simple" a Mac
was by showing its single button mouse alongside a 3 button one from
another windowed environment (possibly DR GEM since Windows was still
in its infancy then).

Although I was using a Mac II at work at the time (and quite enjoying
the novelty) I immediately spotted the fallacy, since there were loads
of actions which had to be performed by holding one of the meta keys
(IIRC there were two, roughly corresponding to <ctrl> amd <alt>) and
clicking the mouse button at the same time. The three button mice of
the time just saved a trip to the keyboard.

More recently, an Apple-head friend was proudly showing off his latest
Mac acquisition and deigned to let me have a go.

Its cordless mouse was featureless apart from a little black nubbin on
the top which I took to be the button, but clicking it appeared not to
do anything. He rather testily pointed out that it should be obvious
you push down on the mouse itself to click (I think you could push on
its left and right sides as well, to get left and right button
functionality), while the nubbin acted as a scroll wheel (basically a
trackball on top of a mouse).

All well and good, but not obvious to someone who hadn't been reading
the Apple magazines and just knew that about this piece of no-doubt
eagerly awaited functionality.

About the same time I read a book on the history of personal computers
and had my suspicions confirmed by the story of Apple guru Steve Jobs
violently resisting pressure to add networking because data transfer
between machines would always be easily achieved by passing round
floppy disks! This story must occured prior to my Mac use (88-89)
since we had 4 Macs connected via AppleTalk, an entirely proprietary
network utilising extremely expensive hardware adapators.

And don't get me started on the filesystem!
--
Jerry Brown

A cat may look at a king
(but probably won't bother)
h***@gmail.com
2020-05-25 09:22:47 UTC
Reply
Permalink
Post by Jerry Brown
There has always been a certain arrogance to Apple, both in its
creators and user base.
Well Jobs paid for that when he refused standard treatments for a treatable cancer...
Post by Jerry Brown
I remember an advert in the eighties highlighting how "simple" a Mac
was by showing its single button mouse alongside a 3 button one from
another windowed environment (possibly DR GEM since Windows was still
in its infancy then).
Although I was using a Mac II at work at the time (and quite enjoying
the novelty) I immediately spotted the fallacy, since there were loads
of actions which had to be performed by holding one of the meta keys
(IIRC there were two, roughly corresponding to <ctrl> amd <alt>) and
clicking the mouse button at the same time. The three button mice of
the time just saved a trip to the keyboard.
Typically you do have your hands on the keyboard, I'm not sure that I'd argue that strongly either way
Post by Jerry Brown
More recently, an Apple-head friend was proudly showing off his latest
Mac acquisition and deigned to let me have a go.
Its cordless mouse was featureless apart from a little black nubbin on
the top which I took to be the button, but clicking it appeared not to
do anything. He rather testily pointed out that it should be obvious
you push down on the mouse itself to click (I think you could push on
its left and right sides as well, to get left and right button
functionality), while the nubbin acted as a scroll wheel (basically a
trackball on top of a mouse).
All well and good, but not obvious to someone who hadn't been reading
the Apple magazines and just knew that about this piece of no-doubt
eagerly awaited functionality.
I'm just looking at my logicitech mouse and it doesn't have clearly apparent left and right buttons either
Post by Jerry Brown
About the same time I read a book on the history of personal computers
and had my suspicions confirmed by the story of Apple guru Steve Jobs
violently resisting pressure to add networking because data transfer
between machines would always be easily achieved by passing round
floppy disks!
They started work on a networking approach in 83 and dropped it because there were so many competing standards, they were expecting to use Token Ring but it was delayed so they developed their own approach based off of the Apple Bus serial stuff in 85.
It was a lot cheaper than Ethernet was at the time (as it was largely using inbuilt hardware)
Post by Jerry Brown
This story must occured prior to my Mac use (88-89)
since we had 4 Macs connected via AppleTalk, an entirely proprietary
network utilising extremely expensive hardware adapators.
Wikipedia claims that the adaptor box was about $50, which was a lot cheaper than ethernet or token ring cards at the time
Post by Jerry Brown
And don't get me started on the filesystem!
Dorothy J Heydt
2020-05-25 14:37:28 UTC
Reply
Permalink
Post by h***@gmail.com
Post by Jerry Brown
There has always been a certain arrogance to Apple, both in its
creators and user base.
Well Jobs paid for that when he refused standard treatments for a treatable cancer...
I didn't know that. What kind of cancer, what kind of treatment?
I won't venture to ask why, having just posted "Holy Cat, the man
was weird" upthread.

"Great wits are sure to madness near allied,
And thin partitions do their bounds divide."
--John Dryden
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Dorothy J Heydt
2020-05-25 14:29:50 UTC
Reply
Permalink
[my tribulations with the beta-version of Mac documentation
snipped]
Post by Jerry Brown
There has always been a certain arrogance to Apple, both in its
creators and user base.
I remember an advert in the eighties highlighting how "simple" a Mac
was by showing its single button mouse alongside a 3 button one from
another windowed environment (possibly DR GEM since Windows was still
in its infancy then).
Although I was using a Mac II at work at the time (and quite enjoying
the novelty) I immediately spotted the fallacy, since there were loads
of actions which had to be performed by holding one of the meta keys
(IIRC there were two, roughly corresponding to <ctrl> amd <alt>) and
clicking the mouse button at the same time. The three button mice of
the time just saved a trip to the keyboard.
Well ... to each his own. I've already told (repeatedly) the
tale of when I had to use a Mac at work (later on, different job),
and after searching the manual in vain, I phone Cupertino and got
hold of a techie whom I asked if there was any way of creating
more HotKeys. He said no. I explained that I wanted to achieve
a workaround whereby I never had to use the mouse at all.

He said in honest bewilderment, "Why would anybody want not to
use the mouse?"

Because it required taking one hand off the keyboard, dammit!

[Note that when I play _Lord of the Rings Online_ there are times
when I have to hold down a key (whether Ctrl, Alt, Shift, or Tab
depends) and depress a trackball key at the same time to get a
particular action. This is not so great a hardship because (a)
I've done it so often that it's all muscle-memory, and (b) the
trackball and its buttons are built into the upper-right corner
of the keyboard.]
Post by Jerry Brown
More recently, an Apple-head friend was proudly showing off his latest
Mac acquisition and deigned to let me have a go.
Its cordless mouse was featureless apart from a little black nubbin on
the top which I took to be the button, but clicking it appeared not to
do anything. He rather testily pointed out that it should be obvious
you push down on the mouse itself to click (I think you could push on
its left and right sides as well, to get left and right button
functionality), while the nubbin acted as a scroll wheel (basically a
trackball on top of a mouse).
All well and good, but not obvious to someone who hadn't been reading
the Apple magazines and just knew that about this piece of no-doubt
eagerly awaited functionality.
Yeah. The Apple mavens knew about it, so *everybody* must know
about it. It's called "selection bias," and it goes "I know (or
like) X, all my friends know/like X, so EVERYBODY must /know/like
X."
Post by Jerry Brown
About the same time I read a book on the history of personal computers
and had my suspicions confirmed by the story of Apple guru Steve Jobs
violently resisting pressure to add networking because data transfer
between machines would always be easily achieved by passing round
floppy disks!
Holy Cat. The man was weird.

Hal comments, "A great believer in sneakernet." And there are
times and places where sneakernet is your best option, but not if
you have to put on your sneakers, grab your floppy [or
equivalent], get in the car and drive several hundred miles to
deliver it.
Post by Jerry Brown
This story must occured prior to my Mac use (88-89)
since we had 4 Macs connected via AppleTalk, an entirely proprietary
network utilising extremely expensive hardware adapators.
And don't get me started on the filesystem!
Okay, I won't.

I am so glad that I am retired and never need lay hand on a Mac
or any other Apple product.
--
Dorothy J. Heydt
Vallejo, California
djheydt at gmail dot com
www.kithrup.com/~djheydt/
Joe Pfeiffer
2020-05-23 20:29:05 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
It will take longer than it does to start looking for the next bit of
code that needs tweaking, which is a lot more fun.
Peter Trei
2020-05-23 20:35:04 UTC
Reply
Permalink
Post by Joe Pfeiffer
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
It will take longer than it does to start looking for the next bit of
code that needs tweaking, which is a lot more fun.
Famously, the original Unix kernel source code included the comment "You are not expected to
understand this." in the process swapping code. But there was a good reason; it applied only
to code compiled on a particular C compiler for the PDP-11.

https://www.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code#%22You_are_not_expected_to_understand_this%22

Pt
h***@gmail.com
2020-05-24 05:37:44 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment?
Not long, it does add up and most of the time a comment on the implementation shouldn't be saying what the code does but why it's being done that way
e.g. it's a lot more useful information to say
"We're sorting it this way because it's normally mostly sorted when it comes in so it performs well"
rather than
"We're doing this type of sort"

The first gives the next person to look at it insight on why a particular choice was made, the second doesn't give them that help (and the code should almost always be clear enough that people can see how it's being done)

That means that the comment should normally stay consistent

There's another level of comments where every method should have a summary of what the function does, basically it's aimed at anybody calling the function being able to tell what it does, what they need to provide and what the risks are
Post by Dorothy J Heydt
Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
So most of us...
Paul S Person
2020-05-24 16:45:04 UTC
Reply
Permalink
Post by Dorothy J Heydt
Post by Jerry Brown
On Fri, 22 May 2020 19:11:25 -0700 (PDT), Default User
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
In fairness, I should point out that it is a /lot/ easier and faster
to just tweak the code. Thus, the comments tend to get a bit ...
outdated.
If you're gonna tweak the code, how much longer will it take to
tweak the comment? Unless you're that variety of programmer
whose grasp of FORTRAN/COBOL/C++/whatever greatly exceeds his
grasp of English?
Depends on how long, complicated, and/or convoluted the comment is.
Some code is /very/ hard to explain clearly. Or there may be a
trade-off: briefly vs clearly and comprehensively.

An alternative solution, as noted by another poster, is to add another
comment explaining what you did. Then, the next time, you have two
/different/ comments, possibly both done by yourself.
--
"I begin to envy Petronius."
"I have envied him long since."
Lynn McGuire
2020-05-23 22:44:56 UTC
Reply
Permalink
Post by Default User
Post by Paul S Person
On Thu, 21 May 2020 18:56:29 -0000 (UTC), Thomas Koenig
Post by Thomas Koenig
Post by Lynn McGuire
xkcd: x
https://xkcd.com/2309/
I say that we tar and feather Cueball. The base code of my calculation
engine was written in Fortran II back in the middle 1960s. I have
entire subroutines with only one letter variables names. X = liquid
flowrates, Y = vapor flowrates, T = temperature, P = pressure, I =
general index, J = supplemental index, K = supplemental supplemental
index, A = calculation intermediate result, B = calculation final result.
Why was that done?
Even the original Fortran had six-letter variables, which was a
great innovation at the time (but of course you had to wait for
Fortran II for subroutines).
But then a /non-programmer/ might be able to understand the program,
and We Can't Have That.
"It was hard to write. It should be hard to read."
Brian
Heh.

Lynn
Loading...