Does an expression in a logical statement need parenthesis for proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
goto L463;
}
be
if ((j1 * i1) < 1) {
goto L463;
}
Hi,
Does an expression in a logical statement need parenthesis for proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿ goto L463;
}
Thanks,
Lynn
Does an expression in a logical statement need parenthesis for proper evaluation in C and/or C++?
Hi,No general statement can be made about that issue. It depends entirely
Does an expression in a logical statement need parenthesis for proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
goto L463;
}
be
if ((j1 * i1) < 1) {
goto L463;
}
Hi,
Does an expression in a logical statement need parenthesis for proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿ goto L463;
}
Thanks,
Lynn
For historical reasons, bitwise or (|) and bitwise and (&) are
exceptions. Unfortunately, correcting that mistake would break
backwards compatibility ...
Otherwise, one or more parentheses
might solve the problem.
James Kuyper <jameskuyper@alumni.caltech.edu> writes:
[...]
Otherwise, one or more parentheses
might solve the problem.
Technically correct (the best kind of correct), but *two* or more
parentheses are even better.
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,
Does an expression in a logical statement need parenthesis for proper
evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Thank you all very much.ÿ BTW, there were parenthesis in the old Fortran code but F2C stripped them out.ÿ I put them back in for my comfort as I
see them.
[...]
There is a proportion of programmers who think it is somehow blasphemy
to use more parentheses in an expression than strictly necessary.ÿ [...]
On 2026-11-06 08:49, David Brown wrote:
[...]
There is a proportion of programmers who think it is somehow blasphemy
to use more parentheses in an expression than strictly necessary.ÿ [...]
"blasphemy", wow! - The exaggerations (despite being here, allegedly, softened by the word "somehow") seem to have become in vogue, lately. (Formerly I saw such argumentation paths prevalently in one specific
poster's posts only. Communication style seems to be infectious. :-)
Most (all?) professionals seem to prefer clearness as you do. Whatever
it needs to obtain that; less parentheses or additional parentheses - depending on the expressions' complexity and context! - Largely still subjective anyway, but less of religious intensity, I'd say.
James Kuyper <jameskuyper@alumni.caltech.edu> writes:I should have said "... one or more matched pairs of parentheses ...".
[...]
Otherwise, one or more parentheses
might solve the problem.
Technically correct (the best kind of correct), but *two* or more
parentheses are even better.
On 2026-11-06 00:42, Lynn McGuire wrote:
Hi,
Does an expression in a logical statement need parenthesis for proper
evaluation in C and/or C++?
No, below (assuming i1 and j1 are arithmetic types (and not used
as "camouflaged" booleans) there's no parenthesis necessary.
The necessity of parentheses depends on the operators used. In
"C" the multiplication has higher precedence than the comparison.
I suggest to get an Operator Precedence Table from the Net and
inspect it until you got familiar with the operator precedences.
Most precedences are anyway sensibly defined as you'd expect it.
But be careful when using bit-expressions with '&', '|', and '^'
especially if used together with the comparison operators.
[...]
Lynn has been working on his "fortran" -> "C++" conversion
for over a decade now. That he isn't familar with the
C operator precedence table is rather frightening.
On 06/11/2026 09:17, Janis Papanagnou wrote:
On 2026-11-06 08:49, David Brown wrote:
[...]
There is a proportion of programmers who think it is somehow
blasphemy to use more parentheses in an expression than strictly
necessary.ÿ [...]
"blasphemy", wow! - The exaggerations (despite being here, allegedly,
softened by the word "somehow") seem to have become in vogue, lately.
(Formerly I saw such argumentation paths prevalently in one specific
poster's posts only. Communication style seems to be infectious. :-)
I thought the term "blasphemy" was so obviously an exaggeration that it could not be taken realistically.ÿ[...]
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,Thank you all very much.ÿ BTW, there were parenthesis in the old
Does an expression in a logical statement need parenthesis for
proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not
be a problem adding the parentheses. Generated code that contains
"goto L463" is clearly not intended for humans anyway (at least, not
without a good deal of effort).
There is a proportion of programmers who think it is somehow blasphemy
to use more parentheses in an expression than strictly necessary.
That type of programmer will also disapprove of the extra braces
around the "goto" in your example.
Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:
On 2026-11-06 00:42, Lynn McGuire wrote:
Hi,
Does an expression in a logical statement need parenthesis for proper
evaluation in C and/or C++?
No, below (assuming i1 and j1 are arithmetic types (and not used
as "camouflaged" booleans) there's no parenthesis necessary.
The necessity of parentheses depends on the operators used. In
"C" the multiplication has higher precedence than the comparison.
I suggest to get an Operator Precedence Table from the Net and
inspect it until you got familiar with the operator precedences.
Most precedences are anyway sensibly defined as you'd expect it.
But be careful when using bit-expressions with '&', '|', and '^'
especially if used together with the comparison operators.
Lynn has been working on his "fortran" -> "C++" conversion
for over a decade now. That he isn't familar with the
C operator precedence table is rather frightening.
Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:
On 2026-11-06 00:42, Lynn McGuire wrote:
Hi,
Does an expression in a logical statement need parenthesis for proper
evaluation in C and/or C++?
No, below (assuming i1 and j1 are arithmetic types (and not used
as "camouflaged" booleans) there's no parenthesis necessary.
The necessity of parentheses depends on the operators used. In
"C" the multiplication has higher precedence than the comparison.
I suggest to get an Operator Precedence Table from the Net and
inspect it until you got familiar with the operator precedences.
Most precedences are anyway sensibly defined as you'd expect it.
But be careful when using bit-expressions with '&', '|', and '^'
especially if used together with the comparison operators.
Lynn has been working on his "fortran" -> "C++" conversion
for over a decade now. That he isn't familar with the
C operator precedence table is rather frightening.
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,
Does an expression in a logical statement need parenthesis for proper
evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Thank you all very much.ÿ BTW, there were parenthesis in the old
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not be
a problem adding the parentheses.ÿ Generated code that contains "goto
L463" is clearly not intended for humans anyway (at least, not without a good deal of effort).
There is a proportion of programmers who think it is somehow blasphemy
to use more parentheses in an expression than strictly necessary.ÿ That
type of programmer will also disapprove of the extra braces around the "goto" in your example.
There is a proportion of programmers who think you should /always/ use parentheses to show the precedence of operators.
Most programmers, I think, are in the middle.ÿ Parentheses here can make
the expression clearer at a glance, but it is also obvious what it means when not using extra parentheses.
situations where the operator precedence is not as well known, or may
differ between programming languages - mixing bitwise and logical
operators and equality operators are examples.
You can get a reasonable balance using gcc's warnings - these also have
the big advantage of making it easy to check!ÿ "-Wparentheses" (enabled
by -Wall) will catch, for example, "a < b == c" which parses as "a < (b
== c)".ÿ If "-Wparentheses" does not lead to complaints, then your
generated code is probably okay without the extra parentheses - but you
can still add them here if you prefer.
In general, I think you want your generated code to pass "gcc -O2 -Wall" cleanly (or the clang equivalent, which is /not/ -Weverything!).ÿ You
may even aim for -Wextra.
David Brown <david.brown@hesbynett.no> writes:
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,Thank you all very much.ÿ BTW, there were parenthesis in the old
Does an expression in a logical statement need parenthesis for
proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not
be a problem adding the parentheses. Generated code that contains
"goto L463" is clearly not intended for humans anyway (at least, not
without a good deal of effort).
My understanding is that the C++ code being generated is intended to be maintained as C++ code. Lynn can confirm or deny that. He's using f2c
and a lot of manual cleanup.
In this particular example:
if ((j1 * i1) < 1)
I find the inner parentheses slightly distracting. I'd wouldn't
write it that way myself, but it wouldn't particularly bother me
if I saw it in someone else's code, and I likely wouldn't mention
it unless asked.
If this were my project, as long as I'm having to do substantial
manual cleanup, I'd probably change it to:
if (j1 * i1) < 1)
In a quick test, f2c didn't add parentheses given a Fortran input of
"if (j1 * i1 < 1)". Either the inner parentheses were there in the
Fortran code, or something else is going on.
There is a proportion of programmers who think it is somehow blasphemy
to use more parentheses in an expression than strictly necessary.
That type of programmer will also disapprove of the extra braces
around the "goto" in your example.
Small quibble: The extra parentheses were in the condition in an "if" statement, not a goto. Parentheses in a "goto" statement would be a
syntax error.
[...]
David Brown <david.brown@hesbynett.no> writes:
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,Thank you all very much.ÿ BTW, there were parenthesis in the old
Does an expression in a logical statement need parenthesis for
proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not
be a problem adding the parentheses. Generated code that contains
"goto L463" is clearly not intended for humans anyway (at least, not
without a good deal of effort).
My understanding is that the C++ code being generated is intended to be maintained as C++ code. Lynn can confirm or deny that. He's using f2c
and a lot of manual cleanup.
In this particular example:
if ((j1 * i1) < 1)
I find the inner parentheses slightly distracting. I'd wouldn't
write it that way myself, but it wouldn't particularly bother me
if I saw it in someone else's code, and I likely wouldn't mention
it unless asked.
If this were my project, as long as I'm having to do substantial
manual cleanup, I'd probably change it to:
if (j1 * i1) < 1)...
David Brown <david.brown@hesbynett.no> writes:
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,Thank you all very much.ÿ BTW, there were parenthesis in the old
Does an expression in a logical statement need parenthesis for
proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not
be a problem adding the parentheses. Generated code that contains
"goto L463" is clearly not intended for humans anyway (at least, not
without a good deal of effort).
My understanding is that the C++ code being generated is intended to be maintained as C++ code. Lynn can confirm or deny that. He's using f2c
and a lot of manual cleanup.
In this particular example:
if ((j1 * i1) < 1)
I find the inner parentheses slightly distracting. I'd wouldn't
write it that way myself, but it wouldn't particularly bother me
if I saw it in someone else's code, and I likely wouldn't mention
it unless asked.
If this were my project, as long as I'm having to do substantial
manual cleanup, I'd probably change it to:
if (j1 * i1) < 1)^^^^^^^^^^^^^^^^^
In a quick test, f2c didn't add parentheses given a Fortran input of
"if (j1 * i1 < 1)". Either the inner parentheses were there in the
Fortran code, or something else is going on.
There is a proportion of programmers who think it is somehow blasphemy
to use more parentheses in an expression than strictly necessary.
That type of programmer will also disapprove of the extra braces
around the "goto" in your example.
Small quibble: The extra parentheses were in the condition in an "if" statement, not a goto. Parentheses in a "goto" statement would be a
syntax error.
[...]
David Brown <david.brown@hesbynett.no> writes:...
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,Thank you all very much.ÿ BTW, there were parenthesis in the old
Does an expression in a logical statement need parenthesis for
proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not
be a problem adding the parentheses. Generated code that contains
"goto L463" is clearly not intended for humans anyway (at least, not
without a good deal of effort).
My understanding is that the C++ code being generated is intended to be maintained as C++ code. Lynn can confirm or deny that. He's using f2c
and a lot of manual cleanup.
On 11/6/2026 12:50 PM, Keith Thompson wrote:
David Brown <david.brown@hesbynett.no> writes:...
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,Thank you all very much.ÿ BTW, there were parenthesis in the old
Does an expression in a logical statement need parenthesis for
proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not
be a problem adding the parentheses. Generated code that contains
"goto L463" is clearly not intended for humans anyway (at least, not
without a good deal of effort).
My understanding is that the C++ code being generated is intended to be
maintained as C++ code. Lynn can confirm or deny that. He's using f2c
and a lot of manual cleanup.
Yes. I am tired of fixing the thousands of Fortran to C calls and C to Fortran calls when we move to a new Fortran compiler or a new C/C++ compiler. This is one of the problems that has kept us on the obsolete Watcom F77/C/C++ compilers for over 30 years.
Yup, I am moving to C++ totally. Actually, a very mild version of
C++ for my 850,000 line calculation engine. No classes, all
character strings in std::string variables, and a few other things.
The old Fortran code was not type safe at all, the new C++ code is
trying to use type safety everywhere.
On 11/6/2026 12:50 PM, Keith Thompson wrote:[...]
If this were my project, as long as I'm having to do substantial
manual cleanup, I'd probably change it to:
if (j1 * i1) < 1)...
Huh? I am confused. Aren't you missing a left parenthesis there?
On Fri, 6 Nov 2026 15:37:33 -0600, Lynn McGuire wrote:
On 11/6/2026 12:50 PM, Keith Thompson wrote:
David Brown <david.brown@hesbynett.no> writes:...
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,Thank you all very much.ÿ BTW, there were parenthesis in the old
Does an expression in a logical statement need parenthesis for
proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not
be a problem adding the parentheses. Generated code that contains
"goto L463" is clearly not intended for humans anyway (at least, not
without a good deal of effort).
My understanding is that the C++ code being generated is intended to be
maintained as C++ code. Lynn can confirm or deny that. He's using f2c
and a lot of manual cleanup.
Yes. I am tired of fixing the thousands of Fortran to C calls and C to
Fortran calls when we move to a new Fortran compiler or a new C/C++
compiler. This is one of the problems that has kept us on the obsolete
Watcom F77/C/C++ compilers for over 30 years.
Fortran's ISO C binding feature fixed this Fortran <--> C issue some
20 years ago. Granted, CFI was not available until 2018.
Does an expression in a logical statement need parenthesis for proper evaluation in C and/or C++?
On 2026-11-06 10:50, David Brown wrote:
On 06/11/2026 09:17, Janis Papanagnou wrote:
On 2026-11-06 08:49, David Brown wrote:
[...]
There is a proportion of programmers who think it is somehow
blasphemy to use more parentheses in an expression than strictly
necessary.ÿ [...]
"blasphemy", wow! - The exaggerations (despite being here, allegedly,
softened by the word "somehow") seem to have become in vogue, lately.
(Formerly I saw such argumentation paths prevalently in one specific
poster's posts only. Communication style seems to be infectious. :-)
I thought the term "blasphemy" was so obviously an exaggeration that
it could not be taken realistically.ÿ[...]
No worries. (You may have noticed my smiley?)
But the intention of my post was also to make obvious to better
not foster such language, even if it was meant as "accentuation".
(You know how pathological some posters can get in that respect.)
David Brown <david.brown@hesbynett.no> writes:
On 06/11/2026 02:07, Lynn McGuire wrote:
On 11/5/2026 5:42 PM, Lynn McGuire wrote:
Hi,Thank you all very much.ÿ BTW, there were parenthesis in the old
Does an expression in a logical statement need parenthesis for
proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Thanks,
Lynn
Fortran code but F2C stripped them out.ÿ I put them back in for my
comfort as I see them.
Since you are generating the C++ code automatically, there should not
be a problem adding the parentheses. Generated code that contains
"goto L463" is clearly not intended for humans anyway (at least, not
without a good deal of effort).
My understanding is that the C++ code being generated is intended to be maintained as C++ code. Lynn can confirm or deny that. He's using f2c
and a lot of manual cleanup.
In this particular example:
if ((j1 * i1) < 1)
I find the inner parentheses slightly distracting. I'd wouldn't
write it that way myself, but it wouldn't particularly bother me
if I saw it in someone else's code, and I likely wouldn't mention
it unless asked.
If this were my project, as long as I'm having to do substantial
manual cleanup, I'd probably change it to:
if (j1 * i1) < 1)
In a quick test, f2c didn't add parentheses given a Fortran input of
"if (j1 * i1 < 1)". Either the inner parentheses were there in the
Fortran code, or something else is going on.
There is a proportion of programmers who think it is somehow blasphemy
to use more parentheses in an expression than strictly necessary.
That type of programmer will also disapprove of the extra braces
around the "goto" in your example.
Small quibble: The extra parentheses were in the condition in an "if" statement, not a goto. Parentheses in a "goto" statement would be a
syntax error.
[...]
My impression is that he is still fiddling with his fork of f2c with an
aim to getting as much automation as he can to minimise the manual
cleanup, but I could easily be wrong here.ÿ I have no idea if it is
possible to automate something to help with such gotos.
On 2026-11-07 12:48, David Brown wrote:Fwiw, I ported some of my work over to AppleSoft BASIC just to show it
[...]
My impression is that he is still fiddling with his fork of f2c with
an aim to getting as much automation as he can to minimise the manual
cleanup, but I could easily be wrong here.ÿ I have no idea if it is
possible to automate something to help with such gotos.
It might suffice for such an automation tasks to just mirror such
'goto' structures (unless you intend to create better structured
code through code transformations). - Not long ago I refactored a
legacy program to obtain an equivalent implementation in another
language and the de-spaghettifying turned out to have been really
nasty. (The code had severely convoluted 'goto's and not a single
structured element.) - In principal it's possible to de-'goto' any
source code to obtain structured code. Since I've no experience
with such tools I'm curious what experiences exists in that respect, especially for trans-language transformations (from a heavily 'goto'
biased language (BASIC, FORTRAN?) to some structured language). -
While looking into the Net and concerning this thread I stumbled
across this reply, though:
ÿ "f2c or pet (for Fortran/C): Older research tools designed
ÿÿ to parse flat code graphs and reconstruct clean, structured
ÿÿ if/else and loop components."
which gave the impression that 'f2c' would be able to remove those
'goto's and so I'm wondering why there's (still) 'goto's in the
OP's sample code.
On 2026-11-07 12:48, David Brown wrote:
[...]
My impression is that he is still fiddling with his fork of f2c with
an aim to getting as much automation as he can to minimise the manual
cleanup, but I could easily be wrong here.ÿ I have no idea if it is
possible to automate something to help with such gotos.
It might suffice for such an automation tasks to just mirror such
'goto' structures (unless you intend to create better structured
code through code transformations). - Not long ago I refactored a
legacy program to obtain an equivalent implementation in another
language and the de-spaghettifying turned out to have been really
nasty. (The code had severely convoluted 'goto's and not a single
structured element.) - In principal it's possible to de-'goto' any
source code to obtain structured code. Since I've no experience
with such tools I'm curious what experiences exists in that respect, especially for trans-language transformations (from a heavily 'goto'
biased language (BASIC, FORTRAN?) to some structured language). -
While looking into the Net and concerning this thread I stumbled
across this reply, though:
ÿ "f2c or pet (for Fortran/C): Older research tools designed
ÿÿ to parse flat code graphs and reconstruct clean, structured
ÿÿ if/else and loop components."
which gave the impression that 'f2c' would be able to remove those
'goto's and so I'm wondering why there's (still) 'goto's in the
OP's sample code.
Janis
On 11/7/2026 1:39 PM, Janis Papanagnou wrote:
[...]
While looking into the Net and concerning this thread I stumbled
across this reply, though:
ÿÿ "f2c or pet (for Fortran/C): Older research tools designed
ÿÿÿ to parse flat code graphs and reconstruct clean, structured
ÿÿÿ if/else and loop components."
which gave the impression that 'f2c' would be able to remove those
'goto's and so I'm wondering why there's (still) 'goto's in the
OP's sample code.
F2C is automagically restructuring my code to the first level.ÿ Maybe
the second level sometimes.ÿ The number of gotos is reduced by 80 or
90%.ÿ Way past the point that I don't care.ÿ If a goto is jumping
halfway down a method then replacing it with a monster if then is just
crazy so F2C skips that case.ÿ I am not modifying F2C anymore.
If wanted, I can post comparisons of a couple of my subroutines and the resulting methods.
Fwiw, I ported some of my work over to AppleSoft BASIC just to show it
can be portable. But, my work needed some recursion. BASIC, good luck. However, there is a way, giving BASIC a stack. So for a simple Koch
fractal based on any line:
[snip]
4040ÿÿÿÿ IF V0(3) < 0 THEN V0(3) = INT(V0(3) - .5)
[...]
On 2026-11-07 21:39, Lynn McGuire wrote:
On 11/7/2026 1:39 PM, Janis Papanagnou wrote:
[...]
While looking into the Net and concerning this thread I stumbled
across this reply, though:
ÿÿ "f2c or pet (for Fortran/C): Older research tools designed
ÿÿÿ to parse flat code graphs and reconstruct clean, structured
ÿÿÿ if/else and loop components."
which gave the impression that 'f2c' would be able to remove those
'goto's and so I'm wondering why there's (still) 'goto's in the
OP's sample code.
F2C is automagically restructuring my code to the first level.ÿ Maybe
the second level sometimes.ÿ The number of gotos is reduced by 80 or
90%.ÿ Way past the point that I don't care.ÿ If a goto is jumping
halfway down a method then replacing it with a monster if then is just
crazy so F2C skips that case.ÿ I am not modifying F2C anymore.
Thanks for that background information.
If wanted, I can post comparisons of a couple of my subroutines and
the resulting methods.
Don't bother, since I'm not doing Fortran, I was just interested
in principle here.
Your numbers of 80-90% reduction is, I think, quite good already.
But given that your C-code sample's label number is still "L463"
I don't want to see that code; I'm still traumatized by the code
that I had tried to de-goto-fy not long ago.
Janis
On 11/7/2026 6:30 PM, Janis Papanagnou wrote:
[...] I'm still traumatized by the code
that I had tried to de-goto-fy not long ago.
At least I do not have any "come from"s in my code.
Does an expression in a logical statement need parenthesis for proper evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿ goto L463;
}
if (j1 * i1 < 1) {The latter one leads to more optimized code !
ÿÿÿ goto L463;
}
...
if ((j1 * i1) < 1) {
ÿÿÿ goto L463;
}
On Thu 11/5/2026 3:42 PM, Lynn McGuire wrote:You are correct, parentheses are not needed. However, there's a related question that could have a different answer: should an arithmetic
Does an expression in a logical statement need parenthesis for properThe whole `j1 * i1 < 1` is an expression in this case. It is parsed in accordance with the grammar, which ultimately makes it equivalent to
evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿ goto L463;
}
`(j1 * i1) < 1`.
Your question seems to suggest that the `j1 * i1` part somehow qualifies
as an expression, while the rest of it does not. That's not how it
works. The language does not give the `j1 * i1` part any special status.
On 2026-11-08 02:13, Lynn McGuire wrote:
On 11/7/2026 6:30 PM, Janis Papanagnou wrote:
[...]ÿ I'm still traumatized by the code
that I had tried to de-goto-fy not long ago.
At least I do not have any "come from"s in my code.
:-)
I suppose you have Intercal in mind? ;-)
Janis
On 2026-11-09 02:32, Andrey Tarasevich wrote:
On Thu 11/5/2026 3:42 PM, Lynn McGuire wrote:
Does an expression in a logical statement need parenthesis for properThe whole `j1 * i1 < 1` is an expression in this case. It is parsed in
evaluation in C and/or C++?
In other words, should
if (j1 * i1 < 1) {
ÿÿÿ goto L463;
}
be
if ((j1 * i1) < 1) {
ÿÿÿ goto L463;
}
accordance with the grammar, which ultimately makes it equivalent to
`(j1 * i1) < 1`.
Your question seems to suggest that the `j1 * i1` part somehow qualifies
as an expression, while the rest of it does not. That's not how it
works. The language does not give the `j1 * i1` part any special status.
You are correct, parentheses are not needed. However, there's a related question that could have a different answer: should an arithmetic
expression that is an operand of a comparison expression be
parenthesized - not because it needs the parenthesis, but to clarify
what the grammar already guarantees?
I tend not to use unnecessary parentheses, and I know the grammar well
enough to correctly identify them - but many people don't know the
grammar that well, which might include the next person to maintain my
code. There are reasonable arguments that I should use parentheses more
than I actually do, for the benefit of such people.
On 11/8/2026 2:55 AM, Janis Papanagnou wrote:
On 2026-11-08 02:13, Lynn McGuire wrote:
On 11/7/2026 6:30 PM, Janis Papanagnou wrote:
[...]ÿ I'm still traumatized by the code
that I had tried to de-goto-fy not long ago.
At least I do not have any "come from"s in my code.
:-)
I suppose you have Intercal in mind? ;-)
Fortran of course.
ÿÿ https://en.wikipedia.org/wiki/COMEFROM
I tend not to use unnecessary parentheses, and I know the grammar
well enough to correctly identify them - but many people don't know
the grammar that well, which might include the next person to
maintain my code.
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar
well enough to correctly identify them - but many people don't know
the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory, surely
they have the ability to look things up online <https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why
aren?t pages that clarify those very issues not already in their
browser bookmarks?
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar
well enough to correctly identify them - but many people don't know
the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory, surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why
aren?t pages that clarify those very issues not already in their
browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer
an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more
tightly without looking it up. If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar
well enough to correctly identify them - but many people don't know
the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory, surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why
aren?t pages that clarify those very issues not already in their
browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer
an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more
tightly without looking it up. If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
On 11/9/2026 6:54 PM, Keith Thompson wrote:
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar
well enough to correctly identify them - but many people don't know
the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory, surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why
aren?t pages that clarify those very issues not already in their
browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer
an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more
tightly without looking it up.ÿ If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
I ship my software written in four different software languages.ÿ C++, Fortran, Visual Basic, and C#.ÿ Remembering the nuances of each is
tricky.ÿ I find it best to be safe.
I have shipped software in about a dozen software languages in my 51
year career.ÿ C++, Fortran IV (66), Fortran 77, Visual Basic,
C#, Turbo
Pascal, Basic, Turbo C, Unix C, IBM 370 Assembler, Intel x86 Assembler,
AWK.ÿ I think that I am leaving out a couple that I cannot remember at
the moment.
Lynn
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar
well enough to correctly identify them - but many people don't know
the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory, surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why
aren?t pages that clarify those very issues not already in their
browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer
an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more
tightly without looking it up. If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
Am 06.11.2026 um 00:42 schrieb Lynn McGuire:
if (j1 * i1 < 1) {The latter one leads to more optimized code !
ÿÿÿÿ goto L463;
}
...
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Op 09.nov.2026 om 10:03 schreef Bonita Montero:
Am 06.11.2026 um 00:42 schrieb Lynn McGuire:
if (j1 * i1 < 1) {The latter one leads to more optimized code !
ÿÿÿÿ goto L463;
}
...
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Really? Why?
On 2026-11-09 12:00, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar well
enough to correctly identify them - but many people don't know the
grammar that well, which might include the next person to maintain my
code. There are reasonable arguments that I should use parentheses more
than I actually do, for the benefit of such people.
I'm "a bit" unsettled by the idea of a programmer who is unfamiliar
with the language in general or the grammar specifically! (I know
there's such folks writing programs.) I wouldn't write programs in
ways to satisfy such folks. I'd certainly write programs in ways to
keep the program maintainable focusing on the language specifics not imagining that the piece of code might be handled by a Neanderthal.
Op 09.nov.2026 om 10:03 schreef Bonita Montero:
Am 06.11.2026 um 00:42 schrieb Lynn McGuire:
if (j1 * i1 < 1) {The latter one leads to more optimized code !
ÿÿÿÿ goto L463;
}
...
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Really? Why?
On 11/9/2026 8:39 PM, Lynn McGuire wrote:
On 11/9/2026 6:54 PM, Keith Thompson wrote:
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar
well enough to correctly identify them - but many people don't know
the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory, surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why
aren?t pages that clarify those very issues not already in their
browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer
an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more
tightly without looking it up.ÿ If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
I ship my software written in four different software languages.ÿ C++,
Fortran, Visual Basic, and C#.ÿ Remembering the nuances of each is
tricky.ÿ I find it best to be safe.
I have shipped software in about a dozen software languages in my 51
year career.ÿ C++, Fortran IV (66), Fortran 77, Visual Basic,
VB 6? Do you use access as well?
C#, Turbo Pascal, Basic, Turbo C, Unix C, IBM 370 Assembler, Intel x86
Assembler, AWK.ÿ I think that I am leaving out a couple that I cannot
remember at the moment.
Lynn
On 11/10/2026 12:25 AM, Chris M. Thomasson wrote:
On 11/9/2026 8:39 PM, Lynn McGuire wrote:
On 11/9/2026 6:54 PM, Keith Thompson wrote:
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar
well enough to correctly identify them - but many people don't know >>>>>> the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory, surely >>>>> they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why
aren?t pages that clarify those very issues not already in their
browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer
an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more
tightly without looking it up.ÿ If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
I ship my software written in four different software languages.ÿ C+
+, Fortran, Visual Basic, and C#.ÿ Remembering the nuances of each is
tricky.ÿ I find it best to be safe.
I have shipped software in about a dozen software languages in my 51
year career.ÿ C++, Fortran IV (66), Fortran 77, Visual Basic,
VB 6? Do you use access as well?
C#, Turbo Pascal, Basic, Turbo C, Unix C, IBM 370 Assembler, Intel
x86 Assembler, AWK.ÿ I think that I am leaving out a couple that I
cannot remember at the moment.
Lynn
Nope.ÿ It is just a sample app with source code to show how to connect
to my DLLs using VB.
I have several samples apps including an Excel
spreadsheet.ÿ I have never used Access.
All of my calculation software is currently Win32 DLLs so my customers
can easily use them for custom calculations.
On 11/10/2026 12:48 PM, Lynn McGuire wrote:
On 11/10/2026 12:25 AM, Chris M. Thomasson wrote:
On 11/9/2026 8:39 PM, Lynn McGuire wrote:
On 11/9/2026 6:54 PM, Keith Thompson wrote:
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar >>>>>>> well enough to correctly identify them - but many people don't know >>>>>>> the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory, surely >>>>>> they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why >>>>>> aren?t pages that clarify those very issues not already in their
browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer
an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more
tightly without looking it up.ÿ If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
I ship my software written in four different software languages.ÿ C+
+, Fortran, Visual Basic, and C#.ÿ Remembering the nuances of each
is tricky.ÿ I find it best to be safe.
I have shipped software in about a dozen software languages in my 51
year career.ÿ C++, Fortran IV (66), Fortran 77, Visual Basic,
VB 6? Do you use access as well?
C#, Turbo Pascal, Basic, Turbo C, Unix C, IBM 370 Assembler, Intel
x86 Assembler, AWK.ÿ I think that I am leaving out a couple that I
cannot remember at the moment.
Lynn
Nope.ÿ It is just a sample app with source code to show how to connect
to my DLLs using VB.
That's fine. Fwiw, I wrote a full blown specialized whole home/pool inspection system using VB 6, Access and Word 6 for my Dad way back in
the day. What service pack are you using? Those were fun... ahh, back in
the day... ;^o
I have several samples apps including an Excel spreadsheet.ÿ I have
never used Access.
Actually, Access worked pretty damn good for my needs. Then, iirc, it
got superseded by SQL server.
All of my calculation software is currently Win32 DLLs so my customers
can easily use them for custom calculations.
Well, that should work fine. Once they know the API, anybody should be
able to use them. Iirc, it was a little strange to map DLL's created in
C to the VB 6 data types. But, can be done for sure.
Am 10.11.2026 um 09:58 schrieb Fred. Zwarts:
Op 09.nov.2026 om 10:03 schreef Bonita Montero:
Am 06.11.2026 um 00:42 schrieb Lynn McGuire:
if (j1 * i1 < 1) {The latter one leads to more optimized code !
ÿÿÿÿ goto L463;
}
...
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Really? Why?
It's faster the more braces you have.
On 11/10/2026 8:41 AM, Bonita Montero wrote:
Am 10.11.2026 um 09:58 schrieb Fred. Zwarts:
Op 09.nov.2026 om 10:03 schreef Bonita Montero:
Am 06.11.2026 um 00:42 schrieb Lynn McGuire:
if (j1 * i1 < 1) {The latter one leads to more optimized code !
ÿÿÿÿ goto L463;
}
...
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Really? Why?
It's faster the more braces you have.
You mean taking pressure off of the compiler stages, or what?
It's actually depending on the quotient of parenthesis and braces,Great !
just to be clear. If the number of braces is f(i) and the number
of parenthesis is f(i+1), where 'f' is the Fibonacci function,
the compiler will be able to create faster code, whereas if these
numbers are swapped it will create slower code. (Obviously, no?)
On Thu, 5 Nov 2026 19:52:31 -0500, James Kuyper wrote:
For historical reasons, bitwise or (|) and bitwise and (&) are
exceptions. Unfortunately, correcting that mistake would break
backwards compatibility ...
The only real issue is that bitwise ops have lower priority than
comparisons, when they should be higher. If they were higher, then an expression like
(bitval & mask) == desired_value
wouldn?t need parentheses.
Realistically, can anyone offer *any* real-world C code that
uses an expression that would be parenthesized like
a & (b == c)
On 06/11/2026 01:12, Lawrence D?Oliveiro wrote:
On Thu, 5 Nov 2026 19:52:31 -0500, James Kuyper wrote:
For historical reasons, bitwise or (|) and bitwise and (&) are
exceptions. Unfortunately, correcting that mistake would break
backwards compatibility ...
The only real issue is that bitwise ops have lower priority than
comparisons, when they should be higher. If they were higher, then an
expression like
(bitval & mask) == desired_value
wouldn?t need parentheses.
Realistically, can anyone offer *any* real-world C code that
uses an expression that would be parenthesized like
a & (b == c)
bitwise ops are well used to do logic on 'booleans'
On 12/11/2026 19:44, Tristan Wibberley wrote:
On 06/11/2026 01:12, Lawrence D?Oliveiro wrote:
On Thu, 5 Nov 2026 19:52:31 -0500, James Kuyper wrote:
For historical reasons, bitwise or (|) and bitwise and (&) are
exceptions. Unfortunately, correcting that mistake would break
backwards compatibility ...
The only real issue is that bitwise ops have lower priority than
comparisons, when they should be higher. If they were higher, then an
expression like
(bitval & mask) == desired_value
wouldn?t need parentheses.
Realistically, can anyone offer *any* real-world C code that
uses an expression that would be parenthesized like
a & (b == c)
bitwise ops are well used to do logic on 'booleans'
oh yeah, for C this is all "int" so I think I would only want to do it
with 2s-complement architectures. I think C++ is fine because they're
"bool" instead.
On 2026-11-09 21:24, Lynn McGuire wrote:
On 11/8/2026 2:55 AM, Janis Papanagnou wrote:
On 2026-11-08 02:13, Lynn McGuire wrote:
On 11/7/2026 6:30 PM, Janis Papanagnou wrote:
[...]ÿ I'm still traumatized by the code
that I had tried to de-goto-fy not long ago.
At least I do not have any "come from"s in my code.
:-)
I suppose you have Intercal in mind? ;-)
Fortran of course.
ÿÿ https://en.wikipedia.org/wiki/COMEFROM
Jesus! 8-o
Interesting article; I didn't know that "joke" was
considered also by those more serious languages.
On 12/11/2026 23:27, Tristan Wibberley wrote:
On 12/11/2026 19:44, Tristan Wibberley wrote:
On 06/11/2026 01:12, Lawrence D?Oliveiro wrote:
On Thu, 5 Nov 2026 19:52:31 -0500, James Kuyper wrote:
For historical reasons, bitwise or (|) and bitwise and (&) are
exceptions. Unfortunately, correcting that mistake would break
backwards compatibility ...
The only real issue is that bitwise ops have lower priority than
comparisons, when they should be higher. If they were higher, then an
expression like
ÿÿÿÿ (bitval & mask) == desired_value
wouldn?t need parentheses.
Realistically, can anyone offer *any* real-world C code that
uses an expression that would be parenthesized like
ÿÿÿÿ a & (b == c)
bitwise ops are well used to do logic on 'booleans'
oh yeah, for C this is all "int" so I think I would only want to do it
with 2s-complement architectures. I think C++ is fine because they're
"bool" instead.
In C, the equality and relational operators evaluate to an "int" value
of either 0 or 1.ÿ They never result in any other value.
The only time an optimising
compiler actually follows the rules about what is and what is not
evaluated, is when there are side-effects that could potentially lead to observable behaviour.
The most sensible way to write your code - IMHO - is to use bitwise
operators only when you actually mean bitwise operations such as
masking.ÿ Use logical operators when you mean logical operations - "this
is true AND that is true" or "this is true OR that is true".ÿ And of
course, use logical operators if you need to rely on the short-circuit evaluation or order of evaluation.
And don't bother with the "register" keyword.ÿ Optimising compilers have ignored that for decades, and C++ removed it in C++17 (while preserving
it as a keyword for future usage).
On 13/11/2026 08:41, David Brown wrote:
On 12/11/2026 23:27, Tristan Wibberley wrote:
On 12/11/2026 19:44, Tristan Wibberley wrote:
On 06/11/2026 01:12, Lawrence D?Oliveiro wrote:
On Thu, 5 Nov 2026 19:52:31 -0500, James Kuyper wrote:
For historical reasons, bitwise or (|) and bitwise and (&) are
exceptions. Unfortunately, correcting that mistake would break
backwards compatibility ...
The only real issue is that bitwise ops have lower priority than
comparisons, when they should be higher. If they were higher, then an >>>>> expression like
ÿÿÿÿ (bitval & mask) == desired_value
wouldn?t need parentheses.
Realistically, can anyone offer *any* real-world C code that
uses an expression that would be parenthesized like
ÿÿÿÿ a & (b == c)
bitwise ops are well used to do logic on 'booleans'
oh yeah, for C this is all "int" so I think I would only want to do it
with 2s-complement architectures. I think C++ is fine because they're
"bool" instead.
In C, the equality and relational operators evaluate to an "int" value
of either 0 or 1.ÿ They never result in any other value.
0 has two representations in 1s-complement, all zeros or all ones. I am worried about that when using bitwise operators to implement logic in
case a comparison yields an all-ones representation of 0. Do comparisons
and ! always produce the all-zeros representation in 1s-complement machines?
The only time an optimising
compiler actually follows the rules about what is and what is not
evaluated, is when there are side-effects that could potentially lead to
observable behaviour.
For sufficiently restrictive definitions of "observable".
Clocks and
voltage drops are observable. Voltage drops in particular can cause explosives to land in the wrong place when other systems don't get the current they need. If you can supply the current without dropping
voltage you still have more heat being produced. It all matters at the extremes.
The most sensible way to write your code - IMHO - is to use bitwise
operators only when you actually mean bitwise operations such as
masking.ÿ Use logical operators when you mean logical operations - "this
is true AND that is true" or "this is true OR that is true".ÿ And of
course, use logical operators if you need to rely on the short-circuit
evaluation or order of evaluation.
Using shortcutting when you don't require shortcutting has a meaningful effect on objective measures of the complexity of the system (as does
using an unspecified order with bitwise operators.
bitwise operators always evaluate both operands but in unspecified order.
logical operators sometimes evaluate only one operand but in specified
order when they evaluate both.
The types of failure that can be caused by that difference can matter.
Using the bitwise operators can cause usage of shared resources to vary across the domain.
Idempotency mitigates this and is advisable widely
anyway, so for techniques to avoid shared resources from existing
anyway.
The integration solutions for such problems are some of the
intuitive ones relied on when integrating independent active systems
anyway (ie, we already think about systems in terms of "the two effects happen, make sure your stuff works in case of whichever order").
One can
signal an effect threshold wrapping the logic in a trigger call and so
forth.
Using the logical operators can cause usage of private resources to vary across the domain. It remains a problem even when other good practices
have been applied.
It's not perfect to use bitwise, clearly, but the alternative complexity
of a configuration (order vs shortcut) is sometimes an opportune
reduction in complexity of a development process or asset lifetime.
And don't bother with the "register" keyword.ÿ Optimising compilers have
ignored that for decades, and C++ removed it in C++17 (while preserving
it as a keyword for future usage).
It ought to have been kept meaningful in C++ to mask operator& at least.
I recall it was at least as early as C++98 that it was noneffective, definitely I know it was before C++17 because I never used C++17.
On 13/11/2026 08:41, David Brown wrote:[...]
In C, the equality and relational operators evaluate to an "int" value
of either 0 or 1.ÿ They never result in any other value.
0 has two representations in 1s-complement, all zeros or all ones. I am worried about that when using bitwise operators to implement logic in
case a comparison yields an all-ones representation of 0. Do comparisons
and ! always produce the all-zeros representation in 1s-complement machines?
And don't bother with the "register" keyword.ÿ Optimising compilers have
ignored that for decades, and C++ removed it in C++17 (while preserving
it as a keyword for future usage).
It ought to have been kept meaningful in C++ to mask operator& at least.
I recall it was at least as early as C++98 that it was noneffective, definitely I know it was before C++17 because I never used C++17.
Tristan Wibberley <tristan.wibberley+netnews2@alumni.manchester.ac.uk> writes:
On 13/11/2026 08:41, David Brown wrote:[...]
In C, the equality and relational operators evaluate to an "int" value
of either 0 or 1.ÿ They never result in any other value.
0 has two representations in 1s-complement, all zeros or all ones. I am
worried about that when using bitwise operators to implement logic in
case a comparison yields an all-ones representation of 0. Do comparisons
and ! always produce the all-zeros representation in 1s-complement machines?
C17 6.2.6.2p3,4:
So the equality and comparison operators never yield a negative zero.
And don't bother with the "register" keyword.ÿ Optimising compilers have >>> ignored that for decades, and C++ removed it in C++17 (while preserving
it as a keyword for future usage).
It ought to have been kept meaningful in C++ to mask operator& at least.
I recall it was at least as early as C++98 that it was noneffective,
definitely I know it was before C++17 because I never used C++17.
I've never had a need to disable unary &. Have you?
On 13/11/2026 16:27, Tristan Wibberley wrote:
On 13/11/2026 08:41, David Brown wrote:
On 12/11/2026 23:27, Tristan Wibberley wrote:
On 12/11/2026 19:44, Tristan Wibberley wrote:
On 06/11/2026 01:12, Lawrence D?Oliveiro wrote:
There is no benefit in using bitwise operators when
the logical operators are appropriate - unless you count "confusing
readers" as a benefit.
The only time an optimising
compiler actually follows the rules about what is and what is not
evaluated, is when there are side-effects that could potentially lead to >>> observable behaviour.
For sufficiently restrictive definitions of "observable".
The C standards define "observable behaviour", and that is the
definition I use.
The most sensible way to write your code - IMHO - is to use bitwise
operators only when you actually mean bitwise operations such as
masking.
Using shortcutting when you don't require shortcutting has a meaningful
effect on objective measures of the complexity of the system (as does
using an unspecified order with bitwise operators.
What meaningful effect?ÿ The evaluation of an expression that does not
affect C observable behaviour has /zero/ "meaningful effect" in C.
But do you understand what "evaluates" means here?
The types of failure that can be caused by that difference can matter.
Do you have an example in mind?ÿ That might make it easier to understand
what you are talking about.
Using the bitwise operators can cause usage of shared resources to vary
across the domain.
I have no idea what you mean by this.
Idempotency mitigates this and is advisable widely
anyway, so for techniques to avoid shared resources from existing
anyway.
I have no idea what you mean by this.ÿ You might be using the word "idempotency" incorrectly.ÿ (An operation "op" is "idempotent" if and
only if "x op x == x" for all "x".)
The integration solutions for such problems are some of the
intuitive ones relied on when integrating independent active systems
anyway (ie, we already think about systems in terms of "the two effects
happen, make sure your stuff works in case of whichever order").
Are you trying to say that since the order of evaluation of the sub- expressions for most operators (including the bitwise ones) is not
specified, your code should not rely on any specific ordering?ÿ That is obviously true.
One can
signal an effect threshold wrapping the logic in a trigger call and so
forth.
Again, I have no idea what you are trying to say here.
Using the logical operators can cause usage of private resources to vary
across the domain. It remains a problem even when other good practices
have been applied.
You are going to have to give examples or explain better.
On 2026-11-06 00:35, Keith Thompson wrote:
James Kuyper <jameskuyper@alumni.caltech.edu> writes:I should have said "... one or more matched pairs of parentheses ...".
[...]
Otherwise, one or more parentheses
might solve the problem.
Technically correct (the best kind of correct), but *two* or more
parentheses are even better.
Am 10.11.2026 um 09:58 schrieb Fred. Zwarts:
Op 09.nov.2026 om 10:03 schreef Bonita Montero:
Am 06.11.2026 um 00:42 schrieb Lynn McGuire:
if (j1 * i1 < 1) {The latter one leads to more optimized code !
ÿÿÿÿ goto L463;
}
...
if ((j1 * i1) < 1) {
ÿÿÿÿ goto L463;
}
Really? Why?
It's faster the more braces you have.
On 06/11/2026 15:33, James Kuyper wrote:
On 2026-11-06 00:35, Keith Thompson wrote:
James Kuyper <jameskuyper@alumni.caltech.edu> writes:I should have said "... one or more matched pairs of parentheses ...".
[...]
Otherwise, one or more parentheses
might solve the problem.
Technically correct (the best kind of correct), but *two* or more
parentheses are even better.
You have clearly suffered the pedants more than one man should have toI am one of the worst pedants you're likely to meet. I cannot object to
bear. I feel for you.
On 2026-11-14 14:05, Tristan Wibberley wrote:
On 06/11/2026 15:33, James Kuyper wrote:
On 2026-11-06 00:35, Keith Thompson wrote:
James Kuyper <jameskuyper@alumni.caltech.edu> writes:
[...]
Otherwise, one or more parentheses
might solve the problem.
Technically correct (the best kind of correct), but *two* or more
parentheses are even better.
I should have said "... one or more matched pairs of parentheses ...".
You have clearly suffered the pedants more than one man should have to
bear. I feel for you.
I am one of the worst pedants you're likely to meet. I cannot object to
such minor pedantry.
James Kuyper <jameskuyper@alumni.caltech.edu> writes:
On 2026-11-14 14:05, Tristan Wibberley wrote:
On 06/11/2026 15:33, James Kuyper wrote:
On 2026-11-06 00:35, Keith Thompson wrote:
James Kuyper <jameskuyper@alumni.caltech.edu> writes:
[...]
Otherwise, one or more parentheses >>>>>> might solve the problem.
Technically correct (the best kind of correct), but *two* or more
parentheses are even better.
I should have said "... one or more matched pairs of parentheses ...".
You have clearly suffered the pedants more than one man should have to
bear. I feel for you.
I am one of the worst pedants you're likely to meet. I cannot object to
such minor pedantry.
Pedants unite!
And my remark was intended mostly for humorous effect.
(Hoping this doesn't start a debate about whether it was funny.)
On 13/11/2026 16:49, David Brown wrote:
On 13/11/2026 16:27, Tristan Wibberley wrote:
On 13/11/2026 08:41, David Brown wrote:
On 12/11/2026 23:27, Tristan Wibberley wrote:
On 12/11/2026 19:44, Tristan Wibberley wrote:
On 06/11/2026 01:12, Lawrence D?Oliveiro wrote:
There is no benefit in using bitwise operators when
the logical operators are appropriate - unless you count "confusing
readers" as a benefit.
That's definitely not true, being able to know both lhs and rhs are
evaluated regardless of the value of the other from just a glance at the
code is beneficial. Begin able to know that, when they're function
calls, side-effects of both will occur is beneficial.
The only time an optimising
compiler actually follows the rules about what is and what is not
evaluated, is when there are side-effects that could potentially lead to >>>> observable behaviour.
For sufficiently restrictive definitions of "observable".
The C standards define "observable behaviour", and that is the
definition I use.
Noted for this occasion, I will forget that you're using it in future.
The most sensible way to write your code - IMHO - is to use bitwise
operators only when you actually mean bitwise operations such as
masking.
For this purpose, they actually are logical too, one of the bits
nominated by the implementation has the required meaning. It is
commonplace to do this when two or more dimensions are involved, this is merely extending the practice down to when just one dimension is involved.
Using shortcutting when you don't require shortcutting has a meaningful
effect on objective measures of the complexity of the system (as does
using an unspecified order with bitwise operators.
What meaningful effect?ÿ The evaluation of an expression that does not
affect C observable behaviour has /zero/ "meaningful effect" in C.
Meaningful effect "on objective measures of the complexity of the
system". shortcutting increases cyclomatic complexity which is often considered a cost.
But do you understand what "evaluates" means here?
Yes. in great detail.
The types of failure that can be caused by that difference can matter.
Do you have an example in mind?ÿ That might make it easier to understand
what you are talking about.
Yes but I'm feeling pretty tired. You will know what kinds of problems
can occur in a system containing a C program among its constituents
based on orderings of effects or based on conditional effects.
Using the bitwise operators can cause usage of shared resources to vary
across the domain.
I have no idea what you mean by this.
Different cases of a function's inputs could make a resource that both operands manipulate change in ways that are described non-uniformly
across cases, extrapolation from test cases to all other cases to
predict compliance can be wrong.
Idempotency mitigates this and is advisable widely
anyway, so for techniques to avoid shared resources from existing
anyway.
I have no idea what you mean by this.ÿ You might be using the word
"idempotency" incorrectly.ÿ (An operation "op" is "idempotent" if and
only if "x op x == x" for all "x".)
I understand the term to be used slightly more broadly but only
slightly. What I had in mind is only irrelevantly different from your definition.
many classes of invalid programs caused by being affected by ordering
can be made valid by using idempotency in their side-effects.
Then I meant "also for techniques..." which are such a big group that
I'm not going to bother giving examples because this has started to feel
like a job interview which I do not want.
The integration solutions for such problems are some of the
intuitive ones relied on when integrating independent active systems
anyway (ie, we already think about systems in terms of "the two effects
happen, make sure your stuff works in case of whichever order").
Are you trying to say that since the order of evaluation of the sub-
expressions for most operators (including the bitwise ones) is not
specified, your code should not rely on any specific ordering?ÿ That is
obviously true.
I'm saying we make systems that do not rely on ordering all the time and
the management of a development process involving just more of the same
is easiest.
One can
signal an effect threshold wrapping the logic in a trigger call and so
forth.
Again, I have no idea what you are trying to say here.
One can call a finalisation function after the conditions have been
evaluated which delimits a segment of program addresses in which some
signal is permissibly invalid. That can include I/O so that external
signals are issued.
Using the logical operators can cause usage of private resources to vary >>> across the domain. It remains a problem even when other good practices
have been applied.
You are going to have to give examples or explain better.
Different cases of a function's inputs could make a resource that the
rhs manipulates change in ways that are described non-uniformly across
cases, extrapolation from test cases to all other cases to predict
compliance can be wrong.
Matters of ordering are experienced through systems at all scales and
are solved with a few practices all over all the systems, in particular, systems are very commonly composed of parts that act independently
except when explicitly excluding each other by signalling protocols (or
by a scheduler or broker). Matters of shortcutting are different so
those very common practices don't all apply helpfully, making
shortcutting, in my mind, a choice to make very cautiously.
James Kuyper <jameskuyper@alumni.caltech.edu> writes:
On 2026-11-14 14:05, Tristan Wibberley wrote:
On 06/11/2026 15:33, James Kuyper wrote:
On 2026-11-06 00:35, Keith Thompson wrote:
James Kuyper <jameskuyper@alumni.caltech.edu> writes:
[...]
Otherwise, one or more parentheses >>>>>> might solve the problem.
Technically correct (the best kind of correct), but *two* or more
parentheses are even better.
I should have said "... one or more matched pairs of parentheses ...".
You have clearly suffered the pedants more than one man should have to
bear. I feel for you.
I am one of the worst pedants you're likely to meet. I cannot object to
such minor pedantry.
Pedants unite!
And my remark was intended mostly for humorous effect. (Hoping
this doesn't start a debate about whether it was funny.)
On 2026-11-15 03:22, Keith Thompson wrote:
James Kuyper <jameskuyper@alumni.caltech.edu> writes:
On 2026-11-14 14:05, Tristan Wibberley wrote:
On 06/11/2026 15:33, James Kuyper wrote:
On 2026-11-06 00:35, Keith Thompson wrote:You have clearly suffered the pedants more than one man should have to >>>> bear. I feel for you.
James Kuyper <jameskuyper@alumni.caltech.edu> writes:
[...]
ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ Otherwise, one or more parentheses >>>>>>> might solve the problem.
Technically correct (the best kind of correct), but *two* or more
parentheses are even better.
I should have said "... one or more matched pairs of parentheses ...". >>>>
I am one of the worst pedants you're likely to meet. I cannot object to
such minor pedantry.
:-)
Pedants unite!
Ped-ants un-ite.
Did it occur to you that "ped" is a Latin prefix for "foot", that
"ants" are insects with many feet, and "ite" in Latin means "go!",
and I wonder why there's the "un" prefix that negates "un-ite" as
"Don't go!". Probably a hidden request to not use "Go" as language
but rather focus on "C" here?!
And my remark was intended mostly for humorous effect.
Please abstain from all humorous statements! - Note: "We [...] do
not have a sense of humor we're aware of." (You know the quote!?)
(Hoping this doesn't start a debate about whether it was funny.)
Oops! - You failed in a way. - Oh, "a way"; we *go* on a way. -
I suspect a conspiracy to subvert the purpose of this newsgroup!
On 15/11/2026 04:28, Janis Papanagnou wrote:
Ped-ants un-ite.
Did it occur to you that "ped" is a Latin prefix for "foot", that
"ants" are insects with many feet, and "ite" in Latin means "go!",
and I wonder why there's the "un" prefix that negates "un-ite" as
"Don't go!". Probably a hidden request to not use "Go" as language
but rather focus on "C" here?!
I'm taking James' claim as a challenge!ÿ A /real/ pedant would know that "ped" is from the /Greek/ word for "child".ÿ The etymology of "pedant"
is an old word for "schoolmaster" or "teacher" (specifically of
children).ÿ :-)
[...] "We [...] do not have a sense of humor we're aware of." [...]
Is it from the USA airport security guard training manual?
(Yes, I know it is from a film, but I can't quite place it at the moment.)
[...]Doesn't it have to be hidden to be a conspiracy?ÿ [...]
I suspect a conspiracy to subvert the purpose of this newsgroup!
On 13/11/2026 23:21, Tristan Wibberley wrote:
On 13/11/2026 16:49, David Brown wrote:
On 13/11/2026 16:27, Tristan Wibberley wrote:
On 13/11/2026 08:41, David Brown wrote:
On 12/11/2026 23:27, Tristan Wibberley wrote:
On 12/11/2026 19:44, Tristan Wibberley wrote:
On 06/11/2026 01:12, Lawrence D?Oliveiro wrote:
There is no benefit in using bitwise operators when
the logical operators are appropriate - unless you count "confusing
readers" as a benefit.
That's definitely not true, being able to know both lhs and rhs are
evaluated regardless of the value of the other from just a glance at the
code is beneficial. Begin able to know that, when they're function
calls, side-effects of both will occur is beneficial.
As I said, there is no benefit in using bitwise operators when logical operators are appropriate. If you are relying on the evaluation of "B"
in the expression "A op B", then using logical operators would not be appropriate.
But I think it could be considered bad style, and potentially confusing,
if you wrote "success = foo() & bar();" where these two functions
returned pass / fail indications and you used this formulation to say
that both had to be run, with "success" being the conjunction. It would
be more idiomatic, I think, to call them separately. With bitwise and
here, readers would wonder if you had really meant to use logical and.
The details of the rest of the code, the names of the functions, and so
on, would of course greatly influence how readers would interpret the
code. But my feeling is that when a reader sees at a glance the bitwise
and operator between two function calls, they would not immediately
conclude that you used bitwise and so that the rhs was also evaluated -
they would guess that you made a mistake in the code.
The only time an optimising
compiler actually follows the rules about what is and what is not
evaluated, is when there are side-effects that could potentially
lead to
observable behaviour.
For sufficiently restrictive definitions of "observable".
The C standards define "observable behaviour", and that is the
definition I use.
Noted for this occasion, I will forget that you're using it in future.
I can try and remember to make it clearer in the future. But since this
is comp.lang.c and comp.lang.c++, and "observable behaviour" is a very specific term from the standards that is critical to understanding the semantics of these languages, I think you should get used to the term.
The word "behaviour" on its own is likely to be used more generally.
The most sensible way to write your code - IMHO - is to use bitwise
operators only when you actually mean bitwise operations such as
masking.
For this purpose, they actually are logical too, one of the bits
nominated by the implementation has the required meaning. It is
commonplace to do this when two or more dimensions are involved, this is
merely extending the practice down to when just one dimension is
involved.
You can certainly use the bitwise operators to have the same effect
effect as the logical operators (apart from evaluation guarantees), in
the same way that you can write "x + x + x" instead of "x * 3" - using
the addition operator to do multiplication. In general, I don't think
it is a good idea, even though compilers will often generate identical
code. You would even get the same results replacing "&&" with "*", but
that would be even less of a good idea.
Using shortcutting when you don't require shortcutting has a meaningful >>>> effect on objective measures of the complexity of the system (as does
using an unspecified order with bitwise operators.
What meaningful effect? The evaluation of an expression that does not
affect C observable behaviour has /zero/ "meaningful effect" in C.
Meaningful effect "on objective measures of the complexity of the
system". shortcutting increases cyclomatic complexity which is often
considered a cost.
Okay, I can see that :
// success = foo() && bar()
bool success = foo();
if (success) {
success = bar();
}
// success = foo() & bar()
bool success_foo = foo();
bool success_bar = bar();
bool success = success_foo & success_bar;
Yes, the conditional increases the cyclomatic complexity of the code.
But while cyclomatic complexity can sometimes be a useful and measurable metric, I am not at all convinced that it is often a particularly useful
one except if you need to give an objective reason why a particular bad function is "clearly incomprehensible".
But do you understand what "evaluates" means here?
Yes. in great detail.
The types of failure that can be caused by that difference can matter.
Do you have an example in mind? That might make it easier to understand >>> what you are talking about.
Yes but I'm feeling pretty tired. You will know what kinds of problems
can occur in a system containing a C program among its constituents
based on orderings of effects or based on conditional effects.
Fair enough. It means that I am sticking to "foo() & bar()" examples,
which might not match what you are thinking about.
Note that when you write "foo() & bar()", where these are both function calls, you are guaranteed that either "far()" is evaluated first and
then "bar()" is evaluated, or vice-versa. You have no control over
their order of evaluation. And if these are not function calls, but are other kinds of sub-expressions (or perhaps macros), their evaluation can
be interleaved.
If you need to control the order of evaluation and side-effects, you
should do so with separate statements. Call "foo" first in one
statement, then call "bar".
Using the bitwise operators can cause usage of shared resources to vary >>>> across the domain.
I have no idea what you mean by this.
Different cases of a function's inputs could make a resource that both
operands manipulate change in ways that are described non-uniformly
across cases, extrapolation from test cases to all other cases to
predict compliance can be wrong.
I still fail to see a relevancy. If you can give an example, great. If
not, I will leave it.
Idempotency mitigates this and is advisable widely
anyway, so for techniques to avoid shared resources from existing
anyway.
I have no idea what you mean by this. You might be using the word
"idempotency" incorrectly. (An operation "op" is "idempotent" if and
only if "x op x == x" for all "x".)
I understand the term to be used slightly more broadly but only
slightly. What I had in mind is only irrelevantly different from your
definition.
Its definition can certainly be broadened beyond just binary operators,
but I agree that would not be relevant.
many classes of invalid programs caused by being affected by ordering
can be made valid by using idempotency in their side-effects.
For example :
bool initialised;
void initialise() {
// Do useful stuff
initialised = true;
}
bool foo() {
if (!initialised) initialise();
return do_foo();
}
bool bar() {
if (!initialised) initialise();
return do_bar();
}
Then it does not matter which of "foo" and "bar" is called first in
"foo() & bar()", because they are "idempotent" in ensuring that the initialisation is done correctly. Is this what you are talking about?
The "static initialisation order fiasco" is a real thing, and programs
have had bugs from getting this kind of thing wrong. But I can't see
its relevance in the choice of using bitwise & for logical operations.
Then I meant "also for techniques..." which are such a big group that
I'm not going to bother giving examples because this has started to feel
like a job interview which I do not want.
I am just trying to understand your perspective, that's all. There is
no job at the end of it, and no pressure for you to write more than you
want to. Discussing how and why people write code in different ways can teach us new ways to write code, or give better appreciation for why
people write or interpret code differently.
The integration solutions for such problems are some of the
intuitive ones relied on when integrating independent active systems
anyway (ie, we already think about systems in terms of "the two effects >>>> happen, make sure your stuff works in case of whichever order").
Are you trying to say that since the order of evaluation of the sub-
expressions for most operators (including the bitwise ones) is not
specified, your code should not rely on any specific ordering? That is
obviously true.
I'm saying we make systems that do not rely on ordering all the time and
the management of a development process involving just more of the same
is easiest.
One can
signal an effect threshold wrapping the logic in a trigger call and so >>>> forth.
Again, I have no idea what you are trying to say here.
One can call a finalisation function after the conditions have been
evaluated which delimits a segment of program addresses in which some
signal is permissibly invalid. That can include I/O so that external
signals are issued.
Using the logical operators can cause usage of private resources to
vary
across the domain. It remains a problem even when other good practices >>>> have been applied.
You are going to have to give examples or explain better.
Different cases of a function's inputs could make a resource that the
rhs manipulates change in ways that are described non-uniformly across
cases, extrapolation from test cases to all other cases to predict
compliance can be wrong.
Matters of ordering are experienced through systems at all scales and
are solved with a few practices all over all the systems, in particular,
systems are very commonly composed of parts that act independently
except when explicitly excluding each other by signalling protocols (or
by a scheduler or broker). Matters of shortcutting are different so
those very common practices don't all apply helpfully, making
shortcutting, in my mind, a choice to make very cautiously.
When you write code in C or C++, you control the order of observable behaviour (as defined by the standards). You don't control any other
order, you don't control any timing, and you don't control when the compiler-generated code does extra work, or skips work, if the work does
not influence observable behaviour.
You should not use && if you want the observable behaviour from the rhs regardless of the value of the lhs. That's not special about
shortcutting logical operators, that's just writing code that does what
you want it to do. Similarly, you should not use & for logical
conjunction if you /do/ want shortcutting semantics.
But IMHO you should not use bitwise & when your code is expressing a
logical intent - just as you should not use "int" when you mean "bool".
That is not directly a matter of code correctness, but it is a matter of
code style and unambiguous understanding from both readers and writers,
and thus a reduction of the risk of bugs.
It is also very common in coding standards to say that statements should
do one thing at a time. Such rules would ban "foo() & bar()" and also
"foo() && bar()" when both functions may have side-effects. Follow that rule, and there is no risk due to the unspecified order of evaluation,
nor any need to be concerned about "idempotency".
On 2026-11-16 09:50, David Brown wrote:
On 15/11/2026 04:28, Janis Papanagnou wrote:
Ped-ants un-ite.
Did it occur to you that "ped" is a Latin prefix for "foot", that
"ants" are insects with many feet, and "ite" in Latin means "go!",
and I wonder why there's the "un" prefix that negates "un-ite" as
"Don't go!". Probably a hidden request to not use "Go" as language
but rather focus on "C" here?!
I'm taking James' claim as a challenge! A /real/ pedant would know
that "ped" is from the /Greek/ word for "child". The etymology of
"pedant" is an old word for "schoolmaster" or "teacher" (specifically
of children). :-)
Ah, it serves me right.
What do I know about Greek. Latin is already demanding enough. :-)
[...] "We [...] do not have a sense of humor we're aware of." [...]
Is it from the USA airport security guard training manual?
(Ouch, yes. - Probably not only in the US. Strange people/processes.)
(Yes, I know it is from a film, but I can't quite place it at the
moment.)
Men in Black. (The agents visiting a lady frustrated by the police,
and Tommy Lee Jones saying that.)
[...]Doesn't it have to be hidden to be a conspiracy? [...]
I suspect a conspiracy to subvert the purpose of this newsgroup!
I thought it had been quite hidden and it got revealed?
Now, unrevealed, the presumed conspiracy theory became a "fact". ;-)
Janis
One way to read what your saying is "algebraizations" and
"arithmetizations", that's the act of interpreting models of
objects their matters of relation according to the matters of
relation of algebras and arithmetic.
On 2026-11-16 09:50, David Brown wrote:
On 15/11/2026 04:28, Janis Papanagnou wrote:
Ped-ants un-ite.
Did it occur to you that "ped" is a Latin prefix for "foot", that
"ants" are insects with many feet, and "ite" in Latin means "go!",
and I wonder why there's the "un" prefix that negates "un-ite" as
"Don't go!". Probably a hidden request to not use "Go" as language
but rather focus on "C" here?!
I'm taking James' claim as a challenge!ÿ A /real/ pedant would know
that "ped" is from the /Greek/ word for "child".ÿ The etymology of
"pedant" is an old word for "schoolmaster" or "teacher" (specifically
of children).ÿ :-)
Ah, it serves me right.
What do I know about Greek. Latin is already demanding enough. :-)
[...] "We [...] do not have a sense of humor we're aware of." [...]
Is it from the USA airport security guard training manual?
(Ouch, yes. - Probably not only in the US. Strange people/processes.)
(Yes, I know it is from a film, but I can't quite place it at the
moment.)
Men in Black. (The agents visiting a lady frustrated by the police,
and Tommy Lee Jones saying that.)
[...]Doesn't it have to be hidden to be a conspiracy?ÿ [...]
I suspect a conspiracy to subvert the purpose of this newsgroup!
I thought it had been quite hidden and it got revealed?
Now, unrevealed, the presumed conspiracy theory became a "fact". ;-)
On 16/11/2026 11:21, Ross Finlayson wrote:
No, that is not a way to read what I wrote. I wrote in English.
One way to read what your saying is "algebraizations" and
"arithmetizations", that's the act of interpreting models of
objects their matters of relation according to the matters of
relation of algebras and arithmetic.
Please find some way to write comprehensibly, without the waffling and rambling, and focusing on the point you are trying to make.
Maybe you could try this for a plan. Before hitting "send" on a post,
give the post to your favourite AI slopbot and ask it to generate a
single paragraph summary. If that summary does not match what you
wanted to say, you know you need to express your post differently. And
if it /does/ match what you want to say, just post that summary so that
other people don't need to wade through your original post.
On 11/16/2026 03:37 AM, David Brown wrote:
On 16/11/2026 11:21, Ross Finlayson wrote:
No, that is not a way to read what I wrote. I wrote in English.
One way to read what your saying is "algebraizations" and
"arithmetizations", that's the act of interpreting models of
objects their matters of relation according to the matters of
relation of algebras and arithmetic.
Please find some way to write comprehensibly, without the waffling and
rambling, and focusing on the point you are trying to make.
Maybe you could try this for a plan. Before hitting "send" on a post,
give the post to your favourite AI slopbot and ask it to generate a
single paragraph summary. If that summary does not match what you
wanted to say, you know you need to express your post differently. And
if it /does/ match what you want to say, just post that summary so that
other people don't need to wade through your original post.
I dispute your estimation of my command of English.
Wherever you got the impression that what I write
isn't perfectly grammatical, if long-winded and
for some a bit the too run-on the style, forget it.
Of course above where I wrote "your" for "you're",
that's intolerable.
Once I asked one of those "on-line grade estimators"
a sample of writing. This is where, for example,
editors of things like newspapers would be aware
of things like "news articles are written toa 6'th
grade reading level".
It said "Grade 26". Maybe it's the reading not
the writing the problem.
I will not insult your intelligence by insulting
your intelligence by insulting your intelligence.
On 11/16/2026 03:37 AM, David Brown wrote:
On 16/11/2026 11:21, Ross Finlayson wrote:
No, that is not a way to read what I wrote.ÿ I wrote in English.
One way to read what your saying is "algebraizations" and
"arithmetizations", that's the act of interpreting models of
objects their matters of relation according to the matters of
relation of algebras and arithmetic.
Please find some way to write comprehensibly, without the waffling and
rambling, and focusing on the point you are trying to make.
Maybe you could try this for a plan.ÿ Before hitting "send" on a post,
give the post to your favourite AI slopbot and ask it to generate a
single paragraph summary.ÿ If that summary does not match what you
wanted to say, you know you need to express your post differently.ÿ And
if it /does/ match what you want to say, just post that summary so that
other people don't need to wade through your original post.
I dispute your estimation of my command of English.
Wherever you got the impression that what I write
isn't perfectly grammatical, if long-winded and
for some a bit the too run-on the style, forget it.
Of course above where I wrote "your" for "you're",
that's intolerable.
[suggestions for writing improvement]
I dispute your estimation of my command of English.
On 16/11/2026 12:57, Ross Finlayson wrote:
On 11/16/2026 03:37 AM, David Brown wrote:
On 16/11/2026 11:21, Ross Finlayson wrote:
No, that is not a way to read what I wrote. I wrote in English.
One way to read what your saying is "algebraizations" and
"arithmetizations", that's the act of interpreting models of
objects their matters of relation according to the matters of
relation of algebras and arithmetic.
Please find some way to write comprehensibly, without the waffling and
rambling, and focusing on the point you are trying to make.
Maybe you could try this for a plan. Before hitting "send" on a post,
give the post to your favourite AI slopbot and ask it to generate a
single paragraph summary. If that summary does not match what you
wanted to say, you know you need to express your post differently. And
if it /does/ match what you want to say, just post that summary so that
other people don't need to wade through your original post.
I dispute your estimation of my command of English.
Wherever you got the impression that what I write
isn't perfectly grammatical, if long-winded and
for some a bit the too run-on the style, forget it.
Of course above where I wrote "your" for "you're",
that's intolerable.
Your grammar is imperfect, but not nearly bad enough to be an issue.
Real problems include your regular use of words and phrases in a way
that simply does not match their meaning. Run-on sentences are bad when
they are too frequent, but made much worse by your overuse of "filler"
words and phrases. Much of what you write would be more appropriate for
a politician giving a filibuster speech.
The root problem, I think, is that you have no focus in your writing.
There is an open conduct between your thoughts and the words you type.
Your thoughts wander, and - like everyone else - /you/ understand what
you are thinking about. But other people do not live in your head. If
you want people to understand what you are thinking about, you have to
write in a way that other people can understand it - not just throw your thoughts at a page randomly.
I believe you have things worth saying. That's why I am trying to
suggest how you can improve your communication skills. Many others just write your posts off as "gobbledegook" or ignore them entirely. (The
number of people that have given such feedback should be an indication
that the problem here is the writer, not the readers.)
This will, I think, be the last post I make directly to you (at least
for a while) - unless you specifically ask for something. If you
understand what I am trying to say, and appreciate that you have a
serious problem communicating, then you can do something about it. If
you don't think that is the case, then you will continue to write posts
that are mostly ignored because they are simply too much effort to read.
On 11/16/2026 06:04 AM, David Brown wrote:
On 16/11/2026 12:57, Ross Finlayson wrote:
On 11/16/2026 03:37 AM, David Brown wrote:
On 16/11/2026 11:21, Ross Finlayson wrote:
No, that is not a way to read what I wrote.ÿ I wrote in English.
One way to read what your saying is "algebraizations" and
"arithmetizations", that's the act of interpreting models of
objects their matters of relation according to the matters of
relation of algebras and arithmetic.
Please find some way to write comprehensibly, without the waffling and >>>> rambling, and focusing on the point you are trying to make.
Maybe you could try this for a plan.ÿ Before hitting "send" on a post, >>>> give the post to your favourite AI slopbot and ask it to generate a
single paragraph summary.ÿ If that summary does not match what you
wanted to say, you know you need to express your post differently.ÿ And >>>> if it /does/ match what you want to say, just post that summary so that >>>> other people don't need to wade through your original post.
I dispute your estimation of my command of English.
Wherever you got the impression that what I write
isn't perfectly grammatical, if long-winded and
for some a bit the too run-on the style, forget it.
Of course above where I wrote "your" for "you're",
that's intolerable.
Your grammar is imperfect, but not nearly bad enough to be an issue.
Real problems include your regular use of words and phrases in a way
that simply does not match their meaning.ÿ Run-on sentences are bad when
they are too frequent, but made much worse by your overuse of "filler"
words and phrases.ÿ Much of what you write would be more appropriate for
a politician giving a filibuster speech.
The root problem, I think, is that you have no focus in your writing.
There is an open conduct between your thoughts and the words you type.
Your thoughts wander, and - like everyone else - /you/ understand what
you are thinking about.ÿ But other people do not live in your head.ÿ If
you want people to understand what you are thinking about, you have to
write in a way that other people can understand it - not just throw your
thoughts at a page randomly.
I believe you have things worth saying.ÿ That's why I am trying to
suggest how you can improve your communication skills.ÿ Many others just
write your posts off as "gobbledegook" or ignore them entirely.ÿ (The
number of people that have given such feedback should be an indication
that the problem here is the writer, not the readers.)
This will, I think, be the last post I make directly to you (at least
for a while) - unless you specifically ask for something.ÿ If you
understand what I am trying to say, and appreciate that you have a
serious problem communicating, then you can do something about it.ÿ If
you don't think that is the case, then you will continue to write posts
that are mostly ignored because they are simply too much effort to read.
Hm. Why, then, thank you good sir, such constructive criticism is
estimated a fair and forthright or the conscientious opinion.
That said, I'll yet aver that my command of the concepts is
very strong, and it's toward, for example, "Grice", "Grice's maxims",
of communication, or for example typical accounts of, "effective communication", vis-a-vis ethos and pathos and kairos here the _logos_,
and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
Thanks for writing.
If I may, I'd then ask "are there any questions or perceived
paradoxes or estimated particulars of incorrectness that it
may help to clarify?"
Some people prefer questions or the pointed, others a sort
of tendered reserve, implying invitation to remarks, then
as to whether, if I suggest that I _would_ ask, is that asking?
That said, then in an obligatory manner about logical statement
and parenthesis, has that precedence is most commonly C and C++'s
vis-a-vis, for example Java's _few_ differences in precedence
of priority of evaluation of operators their expressions in expressions,
and never hurts, except for readability when
it's obvious both the intent and the meaning.
On 16/11/2026 16:33, Ross Finlayson wrote:
On 11/16/2026 06:04 AM, David Brown wrote:
On 16/11/2026 12:57, Ross Finlayson wrote:
On 11/16/2026 03:37 AM, David Brown wrote:
On 16/11/2026 11:21, Ross Finlayson wrote:
No, that is not a way to read what I wrote. I wrote in English.
One way to read what your saying is "algebraizations" and
"arithmetizations", that's the act of interpreting models of
objects their matters of relation according to the matters of
relation of algebras and arithmetic.
Please find some way to write comprehensibly, without the waffling and >>>>> rambling, and focusing on the point you are trying to make.
Maybe you could try this for a plan. Before hitting "send" on a post, >>>>> give the post to your favourite AI slopbot and ask it to generate a
single paragraph summary. If that summary does not match what you
wanted to say, you know you need to express your post differently.
And
if it /does/ match what you want to say, just post that summary so
that
other people don't need to wade through your original post.
I dispute your estimation of my command of English.
Wherever you got the impression that what I write
isn't perfectly grammatical, if long-winded and
for some a bit the too run-on the style, forget it.
Of course above where I wrote "your" for "you're",
that's intolerable.
Your grammar is imperfect, but not nearly bad enough to be an issue.
Real problems include your regular use of words and phrases in a way
that simply does not match their meaning. Run-on sentences are bad when >>> they are too frequent, but made much worse by your overuse of "filler"
words and phrases. Much of what you write would be more appropriate for >>> a politician giving a filibuster speech.
The root problem, I think, is that you have no focus in your writing.
There is an open conduct between your thoughts and the words you type.
Your thoughts wander, and - like everyone else - /you/ understand what
you are thinking about. But other people do not live in your head. If
you want people to understand what you are thinking about, you have to
write in a way that other people can understand it - not just throw your >>> thoughts at a page randomly.
I believe you have things worth saying. That's why I am trying to
suggest how you can improve your communication skills. Many others just >>> write your posts off as "gobbledegook" or ignore them entirely. (The
number of people that have given such feedback should be an indication
that the problem here is the writer, not the readers.)
This will, I think, be the last post I make directly to you (at least
for a while) - unless you specifically ask for something. If you
understand what I am trying to say, and appreciate that you have a
serious problem communicating, then you can do something about it. If
you don't think that is the case, then you will continue to write posts
that are mostly ignored because they are simply too much effort to read. >>>
Hm. Why, then, thank you good sir, such constructive criticism is
estimated a fair and forthright or the conscientious opinion.
That said, I'll yet aver that my command of the concepts is
very strong, and it's toward, for example, "Grice", "Grice's maxims",
of communication, or for example typical accounts of, "effective
communication", vis-a-vis ethos and pathos and kairos here the _logos_,
and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
Thanks for writing.
If I may, I'd then ask "are there any questions or perceived
paradoxes or estimated particulars of incorrectness that it
may help to clarify?"
Some people prefer questions or the pointed, others a sort
of tendered reserve, implying invitation to remarks, then
as to whether, if I suggest that I _would_ ask, is that asking?
That said, then in an obligatory manner about logical statement
and parenthesis, has that precedence is most commonly C and C++'s
vis-a-vis, for example Java's _few_ differences in precedence
of priority of evaluation of operators their expressions in expressions,
and never hurts, except for readability when
it's obvious both the intent and the meaning.
[There's really no reason to read this. I'm sorry ...]
Me:
How do I do list comprehensions in C?
ChatGPT:
[reasonable answer]
Me:
Thanks, but I want the question to be far more verbose. Maybe with more keywords (even if they're not relevant). Basically I want lots of
waffle - even if it makes me sound like an idiot.
ChatGTP:
Ah, I see!
You don't just want to ask how to implement Python-style list
comprehensions in C. You want to wrap the question in an impressive
amount of unnecessarily complicated technical terminology, preferably
making a relatively straightforward programming problem sound like a
major software architecture challenge.
I can certainly help with that. ?
Here's a suitably over-engineered version:
I'm interested in exploring the possibility of implementing a mechanism within the C programming language that provides functionality
conceptually analogous to Python's list comprehension syntax.
More specifically, I'm looking at whether it's possible to introduce a declarative approach to collection construction and transformation,
allowing the generation of derived data structures through the
application of expressions, conditional predicates, iteration strategies
and potentially nested evaluation constructs.
Ideally, I'd like to investigate whether this could be achieved using
some combination of preprocessor macros, generic programming techniques, function pointers, callback mechanisms, higher-order abstractions and possibly C11 language features.
I'm particularly interested in understanding how such an implementation
might facilitate operations equivalent to mapping, filtering,
projection, selection and aggregation, while minimising unnecessary boilerplate and maintaining reasonable levels of type safety, memory management discipline and runtime efficiency.
It would also be interesting to consider whether a lightweight
abstraction layer could provide a more expressive, functional-programming-inspired interface without fundamentally
compromising the procedural nature, portability or performance characteristics of conventional C.
Are there any established design patterns, implementation strategies or library-level approaches that would lend themselves to this kind of functionality? I'd also be interested in any potential limitations
imposed by the language's lack of native closure support, dynamic typing
and built-in collection abstractions.
And if you really want to go overboard, here's a suggested opening
sentence:
"I am seeking to investigate the feasibility of introducing a Python-inspired, declarative, functional-style collection transformation paradigm into an otherwise predominantly imperative, statically typed, low-level systems programming environment."
There. You've turned "How do I do list comprehensions in C?" into
something that sounds like a six-month research project with a steering committee. ?
Me:
Excellent, thank you
ChatGPT:
You're very welcome! ?
Always happy to turn a perfectly sensible programming question into an unnecessarily complicated technical specification.
It's practically an art form. ?
[Sorry again. I shall now crawl back under my rock.]
I dispute your estimation of my command of English.He got that impression directly by reading what you've written. That
Wherever you got the impression that what I write
isn't perfectly grammatical, if long-winded and
for some a bit the too run-on the style, forget it.
That said, I'll yet aver that my command of the concepts is[...]
very strong, and it's toward, for example, "Grice", "Grice's maxims",
of communication, or for example typical accounts of, "effective communication", vis-a-vis ethos and pathos and kairos here the _logos_,
and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...]
That said, I'll yet aver that my command of the concepts is[...]
very strong, and it's toward, for example, "Grice", "Grice's maxims",
of communication, or for example typical accounts of, "effective
communication", vis-a-vis ethos and pathos and kairos here the _logos_,
and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
This is exactly the kind of writing style that makes it difficult,
and frankly not worth the effort, to understand what you're saying.
Perhaps you assume that people know about "Grice's maxims". I *think*
I had heard of them. Looking them up just now, I find that they're a
set of principles for clear and cooperative communication. You seem
to prioritize deliberate obscurity over clarity and informativeness.
Consider the fact that multiple people here have criticized your
writing style, and I'm fairly sure nobody has said anything good
about it.
And while I can't be sure, I don't believe you've written anything interesting enough to be worth the effort of decoding it.
Don't feel obligated to reply to this.
On 11/16/2026 03:17 PM, Keith Thompson wrote:
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...]
That said, I'll yet aver that my command of the concepts is[...]
very strong, and it's toward, for example, "Grice", "Grice's maxims",
of communication, or for example typical accounts of, "effective
communication", vis-a-vis ethos and pathos and kairos here the _logos_,
and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
This is exactly the kind of writing style that makes it difficult,
and frankly not worth the effort, to understand what you're saying.
Perhaps you assume that people know about "Grice's maxims". I *think*
I had heard of them. Looking them up just now, I find that they're a
set of principles for clear and cooperative communication. You seem
to prioritize deliberate obscurity over clarity and informativeness.
Consider the fact that multiple people here have criticized your
writing style, and I'm fairly sure nobody has said anything good
about it.
And while I can't be sure, I don't believe you've written anything
interesting enough to be worth the effort of decoding it.
Don't feel obligated to reply to this.
I blame Wittgenstein, and the Whorfian. So, Wittgenstein was a
"philosopher", and Whorf, a "linguist". And what they say is
that nobody understands anybody. I disagree with this.
(And others do, too.)
Then for example there are accounts of grammar. We all know Chomsky
grammars from computer science, but we all learned Tesniere grammars
in natural language class. They're quite competing accounts.
Grice is basically a reading "The Golden Rule" for language,
"The Golden Rule" has a variety of phrasings, "The Golden Rule",
"The Golden Rules", "The Silver Rule", is basically an account
of "conscientiousness" and "co-operation".
In physics for example there's "shut up and compute".
Yet, that's after accounts of "reductionism", like
"the severe abstraction of the mechanical reduction",
about then that, for example, Lienard-Wiechert's "electron-holes",
are solid-state physics' "Fermi holes", which have more character
than the account of the test charge a point-particle as bodies.
Then, "in the language", always has a wider context. There's
the, "invincible ignorance of inductive inference", that
according to inductive inference, is invincible, yet according
to a wider account of deductive inference, is ignorant.
Then, here, for example, about C and C++, has that C++ has
constructs, "in the language", i.e., according to syntax,
what in C, need to be built as constructs, for example about
implementing variant types in C to make a model of polymorphic
types as C++ already provides. So, from one point-of-view,
they don't exist, in the other, they do. Yet, after account
of comprehending them the _models_, about model theory,
the _structures_, in structured programming, then it's
all one wider language, with _examples_ of the accouts
of what were the _worlds_ of their own accounts, as like
the "internally self-consistent", vis-a-vis, their union.
So, one language's syntax is another's semantics, and vice-versa.
Here for example about precedence/priority and the parenthetical
establishing nesting in what otherwise would the sequential,
about the operations, there's _common syntax_ what for _common
types_ have _common semantics_, they're "the same language",
C and C++, which follows C's. Yet, C++ has "operator overloading",
then it depends on algebraizations of arithmetizations, whether
_all the semantics of arithmetic_, are maintained, in the algebraization
of the arithmetization of C++ in the language
over-loading operators. For example, where they're not, then
"one language's is another's semantics, and vice-versa".
This contrasts with the usual _boundary between syntax and semantics,
that syntax is syntax and semantics is semantics, for whatever
they say the same thing (when they don't).
So, that being topical or relevant, or for Grice which now
we both know, to "does an expression in a logical statement
need parentheses for proper evaluation", is that since both
C and C++ have always the same rules for the syntax, that
"if it does, it does", yet it depends on the actual algebraization
and arithmetization, which is usually implicit, whether the objects
of the algebra model the objects of the arithmetic, and vice-versa,
thus that all the possible derivations, are also well-defined,
where they are or aren't.
Then, in the other thread about "components in C++", where
for example "library author's are responsible for re-usable
code" then "component framework provider's are responsible
for re-usable libraries", as a sort of definition, has for
example that C++ already has a way for this, about what
patterns of the patternry/"module-ry"/componentry, make
that simple, _including modeling the error-handling and
the exception-modeling_, and working that up to what accounts
of strong types that C _does_ have, basically is about other
languages than C/C++, and accounts of features they've had for
a long time, how to design and build those in C and compatible
with C++, for example about reflection-based metaprogramming
or component frameworks like OLE/COM, what simply don't otherwise
already have accounts "in the language", yet do, "in the wider language".
On 11/16/2026 03:17 PM, Keith Thompson wrote:[82 lines deleted]
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...]
That said, I'll yet aver that my command of the concepts is[...]
very strong, and it's toward, for example, "Grice", "Grice's maxims",
of communication, or for example typical accounts of, "effective
communication", vis-a-vis ethos and pathos and kairos here the _logos_,
and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
This is exactly the kind of writing style that makes it difficult,
and frankly not worth the effort, to understand what you're saying.
Perhaps you assume that people know about "Grice's maxims". I *think*
I had heard of them. Looking them up just now, I find that they're a
set of principles for clear and cooperative communication. You seem
to prioritize deliberate obscurity over clarity and informativeness.
Consider the fact that multiple people here have criticized your
writing style, and I'm fairly sure nobody has said anything good
about it.
And while I can't be sure, I don't believe you've written anything
interesting enough to be worth the effort of decoding it.
Don't feel obligated to reply to this.
I blame Wittgenstein, and the Whorfian. So, Wittgenstein was a
"philosopher", and Whorf, a "linguist". And what they say is
that nobody understands anybody. I disagree with this.
(And others do, too.)
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
On 11/16/2026 03:17 PM, Keith Thompson wrote:[82 lines deleted]
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...]
That said, I'll yet aver that my command of the concepts is[...]
very strong, and it's toward, for example, "Grice", "Grice's maxims",
of communication, or for example typical accounts of, "effective
communication", vis-a-vis ethos and pathos and kairos here the _logos_, >>>> and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
This is exactly the kind of writing style that makes it difficult,
and frankly not worth the effort, to understand what you're saying.
Perhaps you assume that people know about "Grice's maxims". I *think*
I had heard of them. Looking them up just now, I find that they're a
set of principles for clear and cooperative communication. You seem
to prioritize deliberate obscurity over clarity and informativeness.
Consider the fact that multiple people here have criticized your
writing style, and I'm fairly sure nobody has said anything good
about it.
And while I can't be sure, I don't believe you've written anything
interesting enough to be worth the effort of decoding it.
Don't feel obligated to reply to this.
I blame Wittgenstein, and the Whorfian. So, Wittgenstein was a
"philosopher", and Whorf, a "linguist". And what they say is
that nobody understands anybody. I disagree with this.
(And others do, too.)
Ross, do you understand that the vast majority of other readers in
this newsgroup *don't know what you're talking about*?
Perhaps you're being very clever in your writing, but the net effect
is that you're posting large volumes of what most or all of us
see as word salad. This isn't about philosophy or linguistics.
It's about *you* using an impenetrable writing style and wasting
everyone's time. That's your fault, not anyone else's.
And your long discourses about linguistics are off-topic in newsgroups
where we discuss the C and C++ programming languages.
Try reading some other articles that have been posted here, and
that have been part of meaninful discussions. Consider trying to
emulate the style of those articles -- *if* you want to talk about
C and C++. If you want to talk about something other than C and C++,
please don't do it here.
Thanks for writing, Keith. To be sure, if there was "offense", or,
you know, "hurt", none was meant, in this case. It's not considered
an affront to be talkative on open forae, "in the spirit of the
charter", say.
On 11/17/2026 01:53 PM, Keith Thompson wrote:
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
On 11/16/2026 03:17 PM, Keith Thompson wrote:[82 lines deleted]
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...]
That said, I'll yet aver that my command of the concepts is[...]
very strong, and it's toward, for example, "Grice", "Grice's maxims", >>>>> of communication, or for example typical accounts of, "effective
communication", vis-a-vis ethos and pathos and kairos here the _logos_, >>>>> and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
This is exactly the kind of writing style that makes it difficult,
and frankly not worth the effort, to understand what you're saying.
Perhaps you assume that people know about "Grice's maxims". I *think* >>>> I had heard of them. Looking them up just now, I find that they're a
set of principles for clear and cooperative communication. You seem
to prioritize deliberate obscurity over clarity and informativeness.
Consider the fact that multiple people here have criticized your
writing style, and I'm fairly sure nobody has said anything good
about it.
And while I can't be sure, I don't believe you've written anything
interesting enough to be worth the effort of decoding it.
Don't feel obligated to reply to this.
I blame Wittgenstein, and the Whorfian. So, Wittgenstein was a
"philosopher", and Whorf, a "linguist". And what they say is
that nobody understands anybody. I disagree with this.
(And others do, too.)
Ross, do you understand that the vast majority of other readers in
this newsgroup *don't know what you're talking about*?
Thanks for writing, Keith. To be sure, if there was "offense", or,
you know, "hurt", none was meant, in this case. It's not considered
an affront to be talkative on open forae, "in the spirit of the
charter", say.
So, first of all, we all know pretty much anything about C and C++,
or it's readily recounted, and to see it's "known" is as we can
read it as we see it, relate it to the standard and formal accounts,
it all makes sense, these are each languages with their syntax and
semantics about the guarantees and behavior, it's the way of the
things. Then, each has their _own_ account, sums of their influences
and state of their consciousness, the many and manifold things.
So, then to talking about C and C++, first of all is that here[...]
it's pretty much: "C/C++".
We all know all this, it's no big deal.
Here then for example, what I'm trying to figure out is basically
how to make for C what's in C++ without being in C++ that's yet
readily adaptable for calling and being called from and into C++
from C.
On 11/10/2026 3:12 PM, Chris M. Thomasson wrote:
On 11/10/2026 12:48 PM, Lynn McGuire wrote:
On 11/10/2026 12:25 AM, Chris M. Thomasson wrote:
On 11/9/2026 8:39 PM, Lynn McGuire wrote:
On 11/9/2026 6:54 PM, Keith Thompson wrote:
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar >>>>>>>> well enough to correctly identify them - but many people don't know >>>>>>>> the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory,
surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why >>>>>>> aren?t pages that clarify those very issues not already in their >>>>>>> browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer >>>>>> an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more >>>>>> tightly without looking it up.ÿ If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
I ship my software written in four different software languages.
C+ +, Fortran, Visual Basic, and C#.ÿ Remembering the nuances of
each is tricky.ÿ I find it best to be safe.
I have shipped software in about a dozen software languages in my
51 year career.ÿ C++, Fortran IV (66), Fortran 77, Visual Basic,
VB 6? Do you use access as well?
C#, Turbo Pascal, Basic, Turbo C, Unix C, IBM 370 Assembler, Intel
x86 Assembler, AWK.ÿ I think that I am leaving out a couple that I
cannot remember at the moment.
Lynn
Nope.ÿ It is just a sample app with source code to show how to
connect to my DLLs using VB.
That's fine. Fwiw, I wrote a full blown specialized whole home/pool
inspection system using VB 6, Access and Word 6 for my Dad way back in
the day. What service pack are you using? Those were fun... ahh, back
in the day... ;^o
I have several samples apps including an Excel spreadsheet.ÿ I have
never used Access.
Actually, Access worked pretty damn good for my needs. Then, iirc, it
got superseded by SQL server.
All of my calculation software is currently Win32 DLLs so my
customers can easily use them for custom calculations.
Well, that should work fine. Once they know the API, anybody should be
able to use them. Iirc, it was a little strange to map DLL's created
in C to the VB 6 data types. But, can be done for sure.
VB6 SP5 IIRC.
On 11/10/2026 3:12 PM, Chris M. Thomasson wrote:
On 11/10/2026 12:48 PM, Lynn McGuire wrote:
On 11/10/2026 12:25 AM, Chris M. Thomasson wrote:
On 11/9/2026 8:39 PM, Lynn McGuire wrote:
On 11/9/2026 6:54 PM, Keith Thompson wrote:
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar >>>>>>>> well enough to correctly identify them - but many people don't know >>>>>>>> the grammar that well, which might include the next person to
maintain my code.
Even if they haven?t committed the precedence table to memory,
surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why >>>>>>> aren?t pages that clarify those very issues not already in their >>>>>>> browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer >>>>>> an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so
I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more >>>>>> tightly without looking it up.ÿ If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
I ship my software written in four different software languages.
C+ +, Fortran, Visual Basic, and C#.ÿ Remembering the nuances of
each is tricky.ÿ I find it best to be safe.
I have shipped software in about a dozen software languages in my
51 year career.ÿ C++, Fortran IV (66), Fortran 77, Visual Basic,
VB 6? Do you use access as well?
C#, Turbo Pascal, Basic, Turbo C, Unix C, IBM 370 Assembler, Intel
x86 Assembler, AWK.ÿ I think that I am leaving out a couple that I
cannot remember at the moment.
Lynn
Nope.ÿ It is just a sample app with source code to show how to
connect to my DLLs using VB.
That's fine. Fwiw, I wrote a full blown specialized whole home/pool
inspection system using VB 6, Access and Word 6 for my Dad way back in
the day. What service pack are you using? Those were fun... ahh, back
in the day... ;^o
I have several samples apps including an Excel spreadsheet.ÿ I have
never used Access.
Actually, Access worked pretty damn good for my needs. Then, iirc, it
got superseded by SQL server.
All of my calculation software is currently Win32 DLLs so my
customers can easily use them for custom calculations.
Well, that should work fine. Once they know the API, anybody should be
able to use them. Iirc, it was a little strange to map DLL's created
in C to the VB 6 data types. But, can be done for sure.
VB6 SP5 IIRC.
On 11/17/2026 01:53 PM, Keith Thompson wrote:
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
On 11/16/2026 03:17 PM, Keith Thompson wrote:[82 lines deleted]
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...]
That said, I'll yet aver that my command of the concepts is[...]
very strong, and it's toward, for example, "Grice", "Grice's maxims", >>>>> of communication, or for example typical accounts of, "effective
communication", vis-a-vis ethos and pathos and kairos here the
_logos_,
and not mambly-pambly sorts manager-speak, nor "control freaks",
I'll aver that the more you know the better it goes.
This is exactly the kind of writing style that makes it difficult,
and frankly not worth the effort, to understand what you're saying.
Perhaps you assume that people know about "Grice's maxims".ÿ I *think* >>>> I had heard of them.ÿ Looking them up just now, I find that they're a
set of principles for clear and cooperative communication.ÿ You seem
to prioritize deliberate obscurity over clarity and informativeness.
Consider the fact that multiple people here have criticized your
writing style, and I'm fairly sure nobody has said anything good
about it.
And while I can't be sure, I don't believe you've written anything
interesting enough to be worth the effort of decoding it.
Don't feel obligated to reply to this.
I blame Wittgenstein, and the Whorfian. So, Wittgenstein was a
"philosopher", and Whorf, a "linguist". And what they say is
that nobody understands anybody. I disagree with this.
(And others do, too.)
Ross, do you understand that the vast majority of other readers in
this newsgroup *don't know what you're talking about*?
Perhaps you're being very clever in your writing, but the net effect
is that you're posting large volumes of what most or all of us
see as word salad.ÿ This isn't about philosophy or linguistics.
It's about *you* using an impenetrable writing style and wasting
everyone's time.ÿ That's your fault, not anyone else's.
And your long discourses about linguistics are off-topic in newsgroups
where we discuss the C and C++ programming languages.
Try reading some other articles that have been posted here, and
that have been part of meaninful discussions.ÿ Consider trying to
emulate the style of those articles -- *if* you want to talk about
C and C++.ÿ If you want to talk about something other than C and C++,
please don't do it here.
Thanks for writing, Keith. To be sure, if there was "offense", or,
you know, "hurt", none was meant, in this case. It's not considered
an affront to be talkative on open forae, "in the spirit of the
charter", say.
Since we are neither pseudonymizing trolls nor sockpuppet-bots,
either of which lies in transgression of the charter, then in
speaking to "comp.lang.c" and "comp.lang.c++", it's well expected
that first of all most-everybody knows most-everything about these
languages, if not necessarily of similar or even equivalent experience,
then when we talk about, for example, "C11" and "C++11", then it's
beyond the surface and as well from many perspectival accounts.
It's not for example necessarily "the standards working groups",
vis-a-vis something like "comp.lang.c++.moderated", which last
it says was looking for a moderator, that we self-regular and
moderate ourselves, including with such gentle remonstrances
as you and others provide, helping express sentiment and reaction,
as part of "letters" and here "belles lettres" and so on.
So, first of all, we all know pretty much anything about C and C++,
or it's readily recounted, and to see it's "known" is as we can
read it as we see it, relate it to the standard and formal accounts,
it all makes sense, these are each languages with their syntax and
semantics about the guarantees and behavior, it's the way of the
things. Then, each has their _own_ account, sums of their influences
and state of their consciousness, the many and manifold things.
So, then to talking about C and C++, first of all is that here
it's pretty much: "C/C++". There've long been def'd or ndef'd
the _cplusplus macro and "extern "C"", it's C/C++ with regards
to both their languages, together "C/C++", then for example with
"C11" for the .h/.c files and "C++11" for the .h/.hpp/.cpp/.cxx/...
C++ files, the sources, according to the compilers, or in all
respect to "GCC", vis-a-vis "g++", "gcc", and C and C++.
We all know all this, it's no big deal.
Then there's that requirement or preference (or inheritance,
often enough) has that some code is C and some code is C++
without C (though, often enough it "is" also "legal in C"),
then various accounts of standards have some people are sticklers
(like for "C99/C++03", some with C++ 08 or 11 or 20 or 23, or what
it is) and some are slackers ("it compiles"), and others, euh,
"stagers", always with the latest bleeding-edge features of the
language since it's not relevant "stability" or that various
accounts of "simplicity" talk past each other. It varies.
Here then for example, what I'm trying to figure out is basically
how to make for C what's in C++ without being in C++ that's yet
readily adaptable for calling and being called from and into C++
from C. Like, for example, "sequence" or "iter", and "lister"
and the like, then for something like "C11 _Generic", making accounts
of generics the types in C vis-a-vis the polymorphic class model
in C++, about "sized" or accounts like "characteristics" of access
of arrays, pointer-offsets, lists, otherwise the usual things,
"holders", "getters and setters", then about "libraries" and
"components", after things like "success_t, error_t, and return_t,
for context_t", definitions of the patterns, that would be generally
suitable for writing libraries in C and having them callable and
calling to and from C++, these are the kinds of things I'm liking
to figure out.
Like for example about how to pass an allocator into C, or making
access of ctx_new/ctx_del or ctx_init/ctx_fini, those being about
storage or lifetime and ownership and responsibility, then for
things like "emit_log" and "emit_metric" and "emit_dump", these
are the kinds of things that later always live in any sort of
application framework, for making good-style.
Parentheses are generally useful in expressions since if they're
nested so deep as to become cumbersome, that's too much on one line.
People are yet expected to be familiar and immediately recognize
accounts like "star-p and post-increment", "the C idiom" (for iterators
and matching iterators), then about: getting _above_ that stuff,
yet, not too high.
Warm, i.e., warm regards.
On 18/11/2026 01:26, Ross Finlayson wrote:
[...]
We are not taking offence at anything.ÿ We are asking that you cut out
the absurd pseudo-intellectual writing.ÿ You seem to love name dropping,
so here is one for you - the Dunning-Kruger effect.ÿ You believe you
have an advanced writing style, but you do not.ÿ A classic sign is the
use of nonsense "Latin plurals" like "forae".ÿ The word "forum" is
English, and its plural in English is "forums".ÿ That the etymology is
Latin is irrelevant.ÿ People that aim to write clearly and simply
without being pretentious write "forums" without thinking about it.
People who study linguistics or more advanced writing understand that "forum" comes from the Latin but in English the plural is "forums".
People that want to show off that they believe they are more "educated"
or "sophisticated" than others, write "forae" (or less inaccurately,
"fora") and feel smug about it.
[...]
On 18/11/2026 09:44, Janis Papanagnou wrote:
<snip>
I want Ross to write in a way that is comprehensible to others, because
I think he has things to say that might be interesting to others. The
way he writes at the moment is often not comprehensible, even after
readers spend considerable time and effort trying to understand him. I
am not trying to "teach an adult person how to talk" - I am trying to
make him understand that he has a problem communicating, and trying to
give some suggestions to help with that.
The alternative is simply to ignore all his posts - I would consider
that a poorer choice.
On 2026-11-18 08:43, David Brown wrote:
On 18/11/2026 01:26, Ross Finlayson wrote:
[...]
We are not taking offence at anything. We are asking that you cut out
the absurd pseudo-intellectual writing. You seem to love name
dropping, so here is one for you - the Dunning-Kruger effect. You
believe you have an advanced writing style, but you do not. A classic
sign is the use of nonsense "Latin plurals" like "forae". The word
"forum" is English, and its plural in English is "forums". That the
etymology is Latin is irrelevant. People that aim to write clearly
and simply without being pretentious write "forums" without thinking
about it. People who study linguistics or more advanced writing
understand that "forum" comes from the Latin but in English the plural
is "forums". People that want to show off that they believe they are
more "educated" or "sophisticated" than others, write "forae" (or less
inaccurately, "fora") and feel smug about it.
Erm..., you mean "forae" is "inaccurate"; not plain wrong!?
The "fora" might be okay in nominative form but depending on
context shouldn't one also expect - exempli gratia! :-) -
"foro" and "foris" (the singular/plural ablative forms).
IOW; why opening the can of worms?! (The dispute got silly.)
WRT the massive comments on Ross' way to express himself...
Teaching adult people how they should talk I consider rude
and presumptuous. He's already been told by multiple posters
that his way of writing is by some considered confusing, or
unnecessary voluminous, or demanding, whatever - now he and
we all, each of use, can decide whether we change, continue,
or stop our communication engagement (here, or in similar
threads).
I'd like to emphasize - and thereby deviate from some other
opinion implied in this thread - that communication is not a
one-way; two parties are involved. (See also Claude Shannon.)
I find his writing more demanding than the usual posts, and
the reference to Wittgenstein might explain something (though
before he mentioned that I was rather thinking more of Kant).
Anyway. The Usenet-Communication Market and time will fix all
discrepancies.
Only, please stop teaching adults! And please omit all those
generalizing statements like "People {do/are} {this/that}".
Janis
[...]
On 11/18/2026 01:56 AM, David Brown wrote:
On 18/11/2026 09:44, Janis Papanagnou wrote:
<snip>
I want Ross to write in a way that is comprehensible to others, because
I think he has things to say that might be interesting to others.ÿ The
way he writes at the moment is often not comprehensible, even after
readers spend considerable time and effort trying to understand him.ÿ I
am not trying to "teach an adult person how to talk" - I am trying to
make him understand that he has a problem communicating, and trying to
give some suggestions to help with that.
The alternative is simply to ignore all his posts - I would consider
that a poorer choice.
I see it more as "communicating about problems" than "problem
communicating", and can see that it results "problems communicating
about problems".
About C and C++ together being C/C++, the compiler/front-end
treats them all the same and even has "FORTRAN" in there too,
I don't much know FORTRAN, yet it's among "models of computation"
with "process models" and "resource models", in: "models of
communication", resulting "object files" with "C symbol exports
and C++ name-manglig C symbol exports".
On 18/11/2026 11:50, Ross Finlayson wrote:
On 11/18/2026 01:56 AM, David Brown wrote:
On 18/11/2026 09:44, Janis Papanagnou wrote:
<snip>
I want Ross to write in a way that is comprehensible to others, because
I think he has things to say that might be interesting to others. The
way he writes at the moment is often not comprehensible, even after
readers spend considerable time and effort trying to understand him. I
am not trying to "teach an adult person how to talk" - I am trying to
make him understand that he has a problem communicating, and trying to
give some suggestions to help with that.
The alternative is simply to ignore all his posts - I would consider
that a poorer choice.
I see it more as "communicating about problems" than "problem
communicating", and can see that it results "problems communicating
about problems".
Then you see it differently from other people - thus you have problems communicating with other people. But this post was clearer than most of
your posts, so I take that as a good sign that you are trying harder. However, I will snip everything that is irrelevant and off-topic.
No, compilers treat the different languages as different languages.
About C and C++ together being C/C++, the compiler/front-end
treats them all the same and even has "FORTRAN" in there too,
I don't much know FORTRAN, yet it's among "models of computation"
with "process models" and "resource models", in: "models of
communication", resulting "object files" with "C symbol exports
and C++ name-manglig C symbol exports".
GCC is an acronym for "GNU Compiler Collection" - it is a collection of several compilers for different languages. Parts of these compilers are shared, but the front-ends are separate for each language. GCC have compilers for C, C++, Objective-C, Objective-C++, D, Go, Rust, Fortran,
Ada, Modula-2, COBOL and Algol 68. They have supported other languages
in the past, and there are a number of gcc forks supporting other
languages.
These are not the same language. There is no language "C/C++", any more
than there is a language "Rust/COBOL". Standard C is mostly, but not entirely, contained as a subset within C++ - and also within D,
Objective-C and Objective-C++. But they are still different languages.
The program "gcc" is not a compiler in and of itself. It is a "driver" program that is used to run GCC's compilers (which are separate programs
for each language), along with additional non-GCC tools like assemblers
and linkers.
It is common for C++ toolchains to support C in addition to C++. Whether
they do so as part of a single monolithic tool, or - like gcc - by using separate tools, depends on the toolchain. The extent to which C is
supported varies. MSVC has good support for C++ standards, but famously
poor support for C standards. Most C compilers do not support C++ at all.
It is common for C++ toolchains to support C in addition to C++.
Whether they do so as part of a single monolithic tool, or - like gcc -
by using separate tools, depends on the toolchain. The extent to which
C is supported varies. MSVC has good support for C++ standards, but
On 11/18/2026 05:07 AM, David Brown wrote:
On 18/11/2026 11:50, Ross Finlayson wrote:
On 11/18/2026 01:56 AM, David Brown wrote:
On 18/11/2026 09:44, Janis Papanagnou wrote:
<snip>
I want Ross to write in a way that is comprehensible to others, because >>>> I think he has things to say that might be interesting to others.ÿ The >>>> way he writes at the moment is often not comprehensible, even after
readers spend considerable time and effort trying to understand him.ÿ I >>>> am not trying to "teach an adult person how to talk" - I am trying to
make him understand that he has a problem communicating, and trying to >>>> give some suggestions to help with that.
The alternative is simply to ignore all his posts - I would consider
that a poorer choice.
I see it more as "communicating about problems" than "problem
communicating", and can see that it results "problems communicating
about problems".
Then you see it differently from other people - thus you have problems
communicating with other people.ÿ But this post was clearer than most of
your posts, so I take that as a good sign that you are trying harder.
However, I will snip everything that is irrelevant and off-topic.
No, compilers treat the different languages as different languages.
About C and C++ together being C/C++, the compiler/front-end
treats them all the same and even has "FORTRAN" in there too,
I don't much know FORTRAN, yet it's among "models of computation"
with "process models" and "resource models", in: "models of
communication", resulting "object files" with "C symbol exports
and C++ name-manglig C symbol exports".
GCC is an acronym for "GNU Compiler Collection" - it is a collection of
several compilers for different languages.ÿ Parts of these compilers are
shared, but the front-ends are separate for each language.ÿ GCC have
compilers for C, C++, Objective-C, Objective-C++, D, Go, Rust, Fortran,
Ada, Modula-2, COBOL and Algol 68.ÿ They have supported other languages
in the past, and there are a number of gcc forks supporting other
languages.
These are not the same language.ÿ There is no language "C/C++", any more
than there is a language "Rust/COBOL".ÿ Standard C is mostly, but not
entirely, contained as a subset within C++ - and also within D,
Objective-C and Objective-C++.ÿ But they are still different languages.
The program "gcc" is not a compiler in and of itself.ÿ It is a "driver"
program that is used to run GCC's compilers (which are separate programs
for each language), along with additional non-GCC tools like assemblers
and linkers.
It is common for C++ toolchains to support C in addition to C++. Whether
they do so as part of a single monolithic tool, or - like gcc - by using
separate tools, depends on the toolchain.ÿ The extent to which C is
supported varies.ÿ MSVC has good support for C++ standards, but famously
poor support for C standards.ÿ Most C compilers do not support C++ at
all.
I look for good influences. I'm watching a talk here from a "Dan Saks",
who's like a "Secretary of the C++ Standards Committee". So,
he's making this talk he's titled: Extern "C": Talking to C Programmers
About C++.
On Wed, 18 Nov 2026 14:07:55 +0100
David Brown <david.brown@hesbynett.no> gabbled:
It is common for C++ toolchains to support C in addition to C++.
Whether they do so as part of a single monolithic tool, or - like gcc
- by using separate tools, depends on the toolchain.ÿ The extent to
which C is supported varies.ÿ MSVC has good support for C++ standards,
but
C++ has to at least support C89 as its what C++ was built out of.
On 18/11/2026 11:50, Ross Finlayson wrote:
On 11/18/2026 01:56 AM, David Brown wrote:
On 18/11/2026 09:44, Janis Papanagnou wrote:
<snip>
I want Ross to write in a way that is comprehensible to others, because
I think he has things to say that might be interesting to others.ÿ The
way he writes at the moment is often not comprehensible, even after
readers spend considerable time and effort trying to understand him.ÿ I
am not trying to "teach an adult person how to talk" - I am trying to
make him understand that he has a problem communicating, and trying to
give some suggestions to help with that.
The alternative is simply to ignore all his posts - I would consider
that a poorer choice.
I see it more as "communicating about problems" than "problem
communicating", and can see that it results "problems communicating
about problems".
Then you see it differently from other people - thus you have problems communicating with other people.ÿ But this post was clearer than most of your posts, so I take that as a good sign that you are trying harder. However, I will snip everything that is irrelevant and off-topic.
No, compilers treat the different languages as different languages.
About C and C++ together being C/C++, the compiler/front-end
treats them all the same and even has "FORTRAN" in there too,
I don't much know FORTRAN, yet it's among "models of computation"
with "process models" and "resource models", in: "models of
communication", resulting "object files" with "C symbol exports
and C++ name-manglig C symbol exports".
GCC is an acronym for "GNU Compiler Collection" - it is a collection of several compilers for different languages.
Parts of these compilers are
shared, but the front-ends are separate for each language.ÿ GCC have compilers for C, C++, Objective-C, Objective-C++, D, Go, Rust, Fortran,
Ada, Modula-2, COBOL and Algol 68.ÿ They have supported other languages
in the past, and there are a number of gcc forks supporting other
languages.
These are not the same language.ÿ There is no language "C/C++", any more than there is a language "Rust/COBOL".ÿ Standard C is mostly, but not entirely, contained as a subset within C++ - and also within D,
Objective-C and Objective-C++.ÿ But they are still different languages.
The program "gcc" is not a compiler in and of itself.ÿ It is a "driver" program that is used to run GCC's compilers (which are separate programs
for each language), along with additional non-GCC tools like assemblers
and linkers.
It is common for C++ toolchains to support C in addition to C++. Whether they do so as part of a single monolithic tool, or - like gcc - by using separate tools, depends on the toolchain.ÿ The extent to which C is supported varies.ÿ MSVC has good support for C++ standards, but famously poor support for C standards.ÿ Most C compilers do not support C++ at all.
On 11/10/2026 1:21 PM, Lynn McGuire wrote:
On 11/10/2026 3:12 PM, Chris M. Thomasson wrote:
On 11/10/2026 12:48 PM, Lynn McGuire wrote:
On 11/10/2026 12:25 AM, Chris M. Thomasson wrote:
On 11/9/2026 8:39 PM, Lynn McGuire wrote:
On 11/9/2026 6:54 PM, Keith Thompson wrote:
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar >>>>>>>>> well enough to correctly identify them - but many people don't >>>>>>>>> know
the grammar that well, which might include the next person to >>>>>>>>> maintain my code.
Even if they haven?t committed the precedence table to memory, >>>>>>>> surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>.
If someone has regular trouble with certain language features, why >>>>>>>> aren?t pages that clarify those very issues not already in their >>>>>>>> browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer >>>>>>> an expression I can read at a glance to one that requires me to
consult some document before I can be sure what it means, just so >>>>>>> I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more >>>>>>> tightly without looking it up.ÿ If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers
would insist on none.
I ship my software written in four different software languages.
C+ +, Fortran, Visual Basic, and C#.ÿ Remembering the nuances of
each is tricky.ÿ I find it best to be safe.
I have shipped software in about a dozen software languages in my >>>>>> 51 year career.ÿ C++, Fortran IV (66), Fortran 77, Visual Basic,
VB 6? Do you use access as well?
C#, Turbo Pascal, Basic, Turbo C, Unix C, IBM 370 Assembler, Intel >>>>>> x86 Assembler, AWK.ÿ I think that I am leaving out a couple that I >>>>>> cannot remember at the moment.
Lynn
Nope.ÿ It is just a sample app with source code to show how to
connect to my DLLs using VB.
That's fine. Fwiw, I wrote a full blown specialized whole home/pool
inspection system using VB 6, Access and Word 6 for my Dad way back
in the day. What service pack are you using? Those were fun... ahh,
back in the day... ;^o
I have several samples apps including an Excel spreadsheet.ÿ I have
never used Access.
Actually, Access worked pretty damn good for my needs. Then, iirc, it
got superseded by SQL server.
All of my calculation software is currently Win32 DLLs so my
customers can easily use them for custom calculations.
Well, that should work fine. Once they know the API, anybody should
be able to use them. Iirc, it was a little strange to map DLL's
created in C to the VB 6 data types. But, can be done for sure.
VB6 SP5 IIRC.
Nice. I think I still have a CD with a SP3. Going from VB to Win32 and
back can be done, but its always felt odd to me.
About C and C++ together being C/C++, the compiler/front-end
treats them all the same and even has "FORTRAN" in there too,
I don't much know FORTRAN, yet it's among "models of computation"
with "process models" and "resource models", in: "models of
communication", resulting "object files" with "C symbol exports
and C++ name-manglig C symbol exports".
About Wittgenstein, people studying logic & history often[...]
arrive at the profundity of the "Tractatus Logicophilosophicus",
which by its name is a worked-over work about logic and philosophy.
On 11/18/2026 1:11 AM, Chris M. Thomasson wrote:
On 11/10/2026 1:21 PM, Lynn McGuire wrote:
On 11/10/2026 3:12 PM, Chris M. Thomasson wrote:
On 11/10/2026 12:48 PM, Lynn McGuire wrote:
On 11/10/2026 12:25 AM, Chris M. Thomasson wrote:
On 11/9/2026 8:39 PM, Lynn McGuire wrote:
On 11/9/2026 6:54 PM, Keith Thompson wrote:VB 6? Do you use access as well?
Lawrence D?Oliveiro <ldo@nz.invalid> writes:
On Mon, 9 Nov 2026 06:00:40 -0500, James Kuyper wrote:
I tend not to use unnecessary parentheses, and I know the grammar >>>>>>>>>> well enough to correctly identify them - but many people don't >>>>>>>>>> know
the grammar that well, which might include the next person to >>>>>>>>>> maintain my code.
Even if they haven?t committed the precedence table to memory, >>>>>>>>> surely
they have the ability to look things up online
<https://en.cppreference.com/c/language/operator_precedence>. >>>>>>>>>
If someone has regular trouble with certain language features, why >>>>>>>>> aren?t pages that clarify those very issues not already in their >>>>>>>>> browser bookmarks?
If I haven't memorized all the precedence levels, I greatly prefer >>>>>>>> an expression I can read at a glance to one that requires me to >>>>>>>> consult some document before I can be sure what it means, just so >>>>>>>> I can continue to the next line of code.
Just one example: I couldn't tell you whether `^` or `|` binds more >>>>>>>> tightly without looking it up.ÿ If you can, that's great.
Preferences for *how many* strictly semantically unnecessary
parentheses are appropriate vary greatly, but few C programmers >>>>>>>> would insist on none.
I ship my software written in four different software languages. >>>>>>> C+ +, Fortran, Visual Basic, and C#.ÿ Remembering the nuances of >>>>>>> each is tricky.ÿ I find it best to be safe.
I have shipped software in about a dozen software languages in my >>>>>>> 51 year career.ÿ C++, Fortran IV (66), Fortran 77, Visual Basic, >>>>>>
C#, Turbo Pascal, Basic, Turbo C, Unix C, IBM 370 Assembler,
Intel x86 Assembler, AWK.ÿ I think that I am leaving out a couple >>>>>>> that I cannot remember at the moment.
Lynn
Nope.ÿ It is just a sample app with source code to show how to
connect to my DLLs using VB.
That's fine. Fwiw, I wrote a full blown specialized whole home/pool
inspection system using VB 6, Access and Word 6 for my Dad way back
in the day. What service pack are you using? Those were fun... ahh,
back in the day... ;^o
I have several samples apps including an Excel spreadsheet.ÿ I have >>>>> never used Access.
Actually, Access worked pretty damn good for my needs. Then, iirc,
it got superseded by SQL server.
All of my calculation software is currently Win32 DLLs so my
customers can easily use them for custom calculations.
Well, that should work fine. Once they know the API, anybody should
be able to use them. Iirc, it was a little strange to map DLL's
created in C to the VB 6 data types. But, can be done for sure.
VB6 SP5 IIRC.
Nice. I think I still have a CD with a SP3. Going from VB to Win32 and
back can be done, but its always felt odd to me.
I do not even have VB6 on my current Win 11 system.ÿ I do have it on my
Win 7 system behind me.
The little shit can run in dosbox. I had it on winnt, me and xp back inAll of my calculation software is currently Win32 DLLs so my
customers can easily use them for custom calculations.
Well, that should work fine. Once they know the API, anybody should >>>>> be able to use them. Iirc, it was a little strange to map DLL's
created in C to the VB 6 data types. But, can be done for sure.
VB6 SP5 IIRC.
Nice. I think I still have a CD with a SP3. Going from VB to Win32
and back can be done, but its always felt odd to me.
I do not even have VB6 on my current Win 11 system.ÿ I do have it on
my Win 7 system behind me.
the day. I still have some legacy boxes, pentium 4's iirc, that have my
old home/pool inspection system still running.
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[word salad snipped
About C and C++ together being C/C++, the compiler/front-end
treats them all the same and even has "FORTRAN" in there too,
I don't much know FORTRAN, yet it's among "models of computation"
with "process models" and "resource models", in: "models of
communication", resulting "object files" with "C symbol exports
and C++ name-manglig C symbol exports".
That one paragraph of your post, unlike the preceding ones, was
fairly straightforward. It was also incorrect.
C and C++ compilers do not share a front end. There are compiler
systems (gcc, clang, MS Visual Studio, probably others) that can
compile either C or C++, but they have distinct front-ends, even
if they share a common language-independent back-end.
C and C++ have different grammars. For example, "class" is a keyword
in C++ but not in C. I'm fairly sure there is no compiler whose
parser component, when processing "int class;", will check which
language it's compiling to determine whether that's a declaration
or a syntax error. There's a C front-end that includes a C parser
that treats "class" as an ordinary identifier, and a C++ front-end
that includes a C++ parser that treats "class" as a keyword.
C and C++ are distinct languages. They are treated by implementations
as distinct languages. "C/C++" is a meaningless marketing term.
On 18/11/2026 23:44, Keith Thompson wrote:
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...][...]
C and C++ are distinct languages.ÿ They are treated by implementations
as distinct languages.ÿ "C/C++" is a meaningless marketing term.
To be fair, "C/C++" was not as meaningless in the very early days of C++
when the language was an experimental "C with classes" extension to C.
Thus there is the rather well-renowned "C/C++ Users Journal".ÿ But by
the time Stroustrup's "The C++ Programming Language" was published in
1985, I would say C++ was established as its own language independent of (but cooperating with) C.ÿ Other people may pick a different date or
event for the division, but they have certainly been distinct languages
for a very long time now.
I want Ross to write in a way that is comprehensible to others, because
I think he has things to say that might be interesting to others.ÿ The
way he writes at the moment is often not comprehensible, even after
readers spend considerable time and effort trying to understand him.
I am not trying to "teach an adult person how to talk" - I am trying to
make him understand that he has a problem communicating, and trying to
give some suggestions to help with that.
The alternative is simply to ignore all his posts - I would consider
that a poorer choice.
On 2026-11-19 08:39, David Brown wrote:
On 18/11/2026 23:44, Keith Thompson wrote:
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...][...]
C and C++ are distinct languages.ÿ They are treated by implementations
as distinct languages.ÿ "C/C++" is a meaningless marketing term.
To be fair, "C/C++" was not as meaningless in the very early days of C++
"C/C++" is still a sensible shortcut formulation if one is referring to common and typical elements of these [two] languages.
when the language was an experimental "C with classes" extension to C.
Thus there is the rather well-renowned "C/C++ Users Journal".ÿ But by
the time Stroustrup's "The C++ Programming Language" was published in
1985, I would say C++ was established as its own language independent
of (but cooperating with) C.ÿ Other people may pick a different date
or event for the division, but they have certainly been distinct
languages for a very long time now.
Janis
On 19/11/2026 09:25, Janis Papanagnou wrote:
On 2026-11-19 08:39, David Brown wrote:
On 18/11/2026 23:44, Keith Thompson wrote:
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...][...]
C and C++ are distinct languages.ÿ They are treated by implementations >>>> as distinct languages.ÿ "C/C++" is a meaningless marketing term.
To be fair, "C/C++" was not as meaningless in the very early days of C++
"C/C++" is still a sensible shortcut formulation if one is referring to
common and typical elements of these [two] languages.
Sure.ÿ But I think you need to be careful that it is clear from the
context whether you are talking about C /and/ C++, C /or/ C++, a common subset of the languages, or an imaginary single language.
Shortcuts are fine when everyone knows what you mean by them!
In fact, with C++ I don't think it always makes sense to talk about "The
C++ language" any more, without additional context.ÿ C++11 is a very significantly different language from the original C++98, and C++23 (and especially the up-and-coming C++26) is very different again.
If and
when C23 gains significant popularity, the same could perhaps be said of C.
[...]
On 2026-11-19 11:02, David Brown wrote:
On 19/11/2026 09:25, Janis Papanagnou wrote:
On 2026-11-19 08:39, David Brown wrote:
On 18/11/2026 23:44, Keith Thompson wrote:
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...][...]
C and C++ are distinct languages.ÿ They are treated by implementations >>>>> as distinct languages.ÿ "C/C++" is a meaningless marketing term.
To be fair, "C/C++" was not as meaningless in the very early days of
C++
"C/C++" is still a sensible shortcut formulation if one is referring to
common and typical elements of these [two] languages.
Sure.ÿ But I think you need to be careful that it is clear from the
context whether you are talking about C /and/ C++, C /or/ C++, a
common subset of the languages, or an imaginary single language.
All fair points. - Where the context requires it they should clearly
be differentiated.
(I had the impression that in Ross posts it was clear, but given that
there's some confusion with his style and thinking it might not have
been as obvious and unambiguous as it may have appeared to me.)
To the limited extent that his posts seemed clear to me, he had been
talking about the imaginary single language that compilers "treat as
being the same".ÿ It does not appear that he understands that they are
two different languages sharing a common subset, and that they are often used in very different ways.ÿ So if he was clear, he was clearly wrong.
But maybe I (and others) have misunderstood him.ÿ It would be helpful if
he clarified things, and said that he now understands what Keith and I wrote.ÿ Once we get on common ground, maybe we can move forward.ÿ But I
am not holding my breath.
On 2026-11-19 13:33, David Brown wrote:
To the limited extent that his posts seemed clear to me, he had been
talking about the imaginary single language that compilers "treat as
being the same".ÿ It does not appear that he understands that they are
two different languages sharing a common subset, and that they are
often used in very different ways.ÿ So if he was clear, he was clearly
wrong. But maybe I (and others) have misunderstood him.ÿ It would be
helpful if he clarified things, and said that he now understands what
Keith and I wrote.ÿ Once we get on common ground, maybe we can move
forward.ÿ But I am not holding my breath.
It may be that I've read past some "formally wrong" statements he made.
It's that I usually try to understand what one wants to express beyond
how it's actually formulated. - Maybe it's what (I think) Dan has once formulated; that it might distract the discussion if one isn't focused
on the topic but more concerned about "exact" representation. - I think
that observation is worthwhile to think about! - But I also know that
some folks - you know who they are! - are now tempted to point out the
very importance of exact representation. That's also not wrong but it's missing the point made.[*]
Janis
[*] I tried anticipating that point to prevent unnecessary replies.
On 2026-11-19 13:33, David Brown wrote:
To the limited extent that his posts seemed clear to me, he had been
talking about the imaginary single language that compilers "treat as
being the same". It does not appear that he understands that they are
two different languages sharing a common subset, and that they are
often used in very different ways. So if he was clear, he was clearly
wrong. But maybe I (and others) have misunderstood him. It would be
helpful if he clarified things, and said that he now understands what
Keith and I wrote. Once we get on common ground, maybe we can move
forward. But I am not holding my breath.
It may be that I've read past some "formally wrong" statements he made.
It's that I usually try to understand what one wants to express beyond
how it's actually formulated. - Maybe it's what (I think) Dan has once formulated; that it might distract the discussion if one isn't focused
on the topic but more concerned about "exact" representation. - I think
that observation is worthwhile to think about! - But I also know that
some folks - you know who they are! - are now tempted to point out the
very importance of exact representation. That's also not wrong but it's missing the point made.[*]
Janis
[*] I tried anticipating that point to prevent unnecessary replies.
On 11/19/2026 05:36 AM, Janis Papanagnou wrote:
On 2026-11-19 13:33, David Brown wrote:
To the limited extent that his posts seemed clear to me, he had been
talking about the imaginary single language that compilers "treat as
being the same". It does not appear that he understands that they are
two different languages sharing a common subset, and that they are
often used in very different ways. So if he was clear, he was clearly
wrong. But maybe I (and others) have misunderstood him. It would be
helpful if he clarified things, and said that he now understands what
Keith and I wrote. Once we get on common ground, maybe we can move
forward. But I am not holding my breath.
It may be that I've read past some "formally wrong" statements he made.
It's that I usually try to understand what one wants to express beyond
how it's actually formulated. - Maybe it's what (I think) Dan has once
formulated; that it might distract the discussion if one isn't focused
on the topic but more concerned about "exact" representation. - I think
that observation is worthwhile to think about! - But I also know that
some folks - you know who they are! - are now tempted to point out the
very importance of exact representation. That's also not wrong but it's
missing the point made.[*]
Janis
[*] I tried anticipating that point to prevent unnecessary replies.
I'm a formalist, meaning, representation theory is part of model theory, about language and interpretation.
It's like this hypothetical sort of conversation for example.
"Here's this project you'll be working on, here are the sources."
"I see the identifiers are Pascal-style."
"Yes, this code was long-ago first written in Pascal."
"I see all these .c and .cpp files."
"Yes, those are C and C++ sources."
"Then, those are in the C language and the C++ language."
"Yes, it's C/C++."
"What do you call this?"
"Windows."
gcc -std=C11 | gcc -std=C++11
"How about this one?"
"Oh that's Linux, it was written all in C, yet recently they started
letting in this 'Rust', which has a very strange way of looking at over-riding the declarations of identifiers and re-using them in
block-scope about the statement block. That's mostly due Google/Android
and making everything more polyglot so eventually
they'll fall under their LLVM/MLIR fiefdom to compile all this polyglotty."
"Hm, what tooling am I going to need for that?"
"Yeah I don't know, all we have here is gcc. Though, there is an
idea they're moving from C90 to C99 in 2026."
I'm a formalist, and accept and even invite correction:
Aristotle will not be made a fool, and Hegel will not be made a liar.
Then, "C/C++" is any code-base with both C and C++ sources,
which most accounts of systems-programming employing C++ include.
On 11/19/2026 07:14 AM, Ross Finlayson wrote:
On 11/19/2026 05:36 AM, Janis Papanagnou wrote:
On 2026-11-19 13:33, David Brown wrote:
To the limited extent that his posts seemed clear to me, he had been
talking about the imaginary single language that compilers "treat as
being the same". It does not appear that he understands that they are >>>> two different languages sharing a common subset, and that they are
often used in very different ways. So if he was clear, he was clearly >>>> wrong. But maybe I (and others) have misunderstood him. It would be
helpful if he clarified things, and said that he now understands what
Keith and I wrote. Once we get on common ground, maybe we can move
forward. But I am not holding my breath.
It may be that I've read past some "formally wrong" statements he made.
It's that I usually try to understand what one wants to express beyond
how it's actually formulated. - Maybe it's what (I think) Dan has once
formulated; that it might distract the discussion if one isn't focused
on the topic but more concerned about "exact" representation. - I think
that observation is worthwhile to think about! - But I also know that
some folks - you know who they are! - are now tempted to point out the
very importance of exact representation. That's also not wrong but it's
missing the point made.[*]
Janis
[*] I tried anticipating that point to prevent unnecessary replies.
I'm a formalist, meaning, representation theory is part of model theory,
about language and interpretation.
It's like this hypothetical sort of conversation for example.
"Here's this project you'll be working on, here are the sources."
"I see the identifiers are Pascal-style."
"Yes, this code was long-ago first written in Pascal."
"I see all these .c and .cpp files."
"Yes, those are C and C++ sources."
"Then, those are in the C language and the C++ language."
"Yes, it's C/C++."
"What do you call this?"
"Windows."
gcc -std=C11 | gcc -std=C++11
"How about this one?"
"Oh that's Linux, it was written all in C, yet recently they started
letting in this 'Rust', which has a very strange way of looking at
over-riding the declarations of identifiers and re-using them in
block-scope about the statement block. That's mostly due Google/Android
and making everything more polyglot so eventually
they'll fall under their LLVM/MLIR fiefdom to compile all this
polyglotty."
"Hm, what tooling am I going to need for that?"
"Yeah I don't know, all we have here is gcc. Though, there is an
idea they're moving from C90 to C99 in 2026."
I'm a formalist, and accept and even invite correction:
Aristotle will not be made a fool, and Hegel will not be made a liar.
Then, "C/C++" is any code-base with both C and C++ sources,
which most accounts of systems-programming employing C++ include.
"What are all these .cs files in the application/tool builds?"
"Well you see there was this language including a model of the
virtual machine called Java, which was originally for set-top television-boxes with ideas of a virtual layer above the hardware
and both an account of memory-reclamation called the garbage collector
and also an account of security-layer called the security manager,
so that mis-behaved applications couldn't access system files and
that simply-implemented accounts of scope & state in the runtime
would have their resources cleaned up."
"Yeah, so?"
"So anyways this shop over here had a bunch of products called
'VB' and later 'VBA' that according to their component model
called 'OLE' later 'OLE2' that morphed up to 'COM' and 'ActiveX'
and 'DCOM' made for components in these systems, yet, that shop
over there was making 'Java Beans' about things like 'CORBA',
about the distributed-world of things, anyways these shops were
eating each other's lunch. So, this shop over here basically
decided to wrap up these ideas into something called a 'Common
Language Runtime' which they sort of branded '.NET' which has
a common sort of intermediate language for a virtual machine
called 'IL' intermediate-language, then one of the dialects
they worked up out of that was called 'C-sharp', besides some
things like 'F-sharp', then basically glommed it all together,
so basically you can expect that these .cs files are C#,
and they act pretty much like Java."
"So, ...."
"So a bunch of the industry started requiring Java for everything
because mostly since it was so well-designed the language overall
and it had the account of strong-types then this memory-helper bit,
and it was write-once-run-everywhere, then though with the advanced
language features that got all bloated into framework and a bunch
of different frameworks basically with this 'Spring' outfit sitting
on top of 'Java', it's unavoidable in a bunch of different systems
in the enterprise since these things."
"Yeah so what."
"Well you see then some people think easier (more easily) when the
language doesn't make them speak 'correctly' according to the theory of strong types, then in the explosion of code all over the place, there
were a bunch of accounts of languages and runtimes like JavaScript after
Perl and Ruby and Python, these languages being interpreted instead of compiled to an intermediate representation for a virtual machine or
compiled to machine code and objects that basically communicate with the system according to the calling conventions more than less designed for
C, and all those then have various accounts of how they use C, except JavaScript, which mostly runs in the browser yet then later coders
knowing that started to use it for processes themselves. Then a bunch of newer languages like Go since Ruby
and Kotlin minimizing Java, Zig, that Rust again, pretty much
compiling directly to the C or Java interfaces."
"So, what's this then?"
"Well, it pretty much resolves to C, ..., all these languages at
least in part have "C-like syntax", if they're not making idioms
for regular expressions or shell-script familiarity and these kinds
of things, then they pretty much got their object-orientation from
C++ instead of things like SmallTalk or then that Java was everywhere,
so pretty much resolves to C++ with though the idiom of Java widely."
"So, is this C/C++?"
"Oh no, only C/C++ is C/C++."
"How do we build all this stuff?"
"Oh, you run it in the shell."
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...]
About Wittgenstein, people studying logic & history oftenphilosophy.
arrive at the profundity of the "Tractatus Logicophilosophicus",
which by its name is a worked-over work about logic and
[...]
Please stop.
On 11/19/2026 05:36 AM, Janis Papanagnou wrote:
On 2026-11-19 13:33, David Brown wrote:
To the limited extent that his posts seemed clear to me, he had been
talking about the imaginary single language that compilers "treat as
being the same".ÿ It does not appear that he understands that they are
two different languages sharing a common subset, and that they are
often used in very different ways.ÿ So if he was clear, he was clearly
wrong. But maybe I (and others) have misunderstood him.ÿ It would be
helpful if he clarified things, and said that he now understands what
Keith and I wrote.ÿ Once we get on common ground, maybe we can move
forward.ÿ But I am not holding my breath.
It may be that I've read past some "formally wrong" statements he made.
It's that I usually try to understand what one wants to express beyond
how it's actually formulated. - Maybe it's what (I think) Dan has once
formulated; that it might distract the discussion if one isn't focused
on the topic but more concerned about "exact" representation. - I think
that observation is worthwhile to think about! - But I also know that
some folks - you know who they are! - are now tempted to point out the
very importance of exact representation. That's also not wrong but it's
missing the point made.[*]
Janis
[*] I tried anticipating that point to prevent unnecessary replies.
Then, "C/C++" is any code-base with both C and C++ sources,
which most accounts of systems-programming employing C++ include.
On 11/18/2026 4:53 PM, Chris M. Thomasson wrote:Sure it (VB6) can. You can install say, winme, or whatever on a hd image
...
The little shit can run in dosbox. I had it on winnt, me and xp backVB6 SP5 IIRC.All of my calculation software is currently Win32 DLLs so my
customers can easily use them for custom calculations.
Well, that should work fine. Once they know the API, anybody
should be able to use them. Iirc, it was a little strange to map
DLL's created in C to the VB 6 data types. But, can be done for sure. >>>>>
Nice. I think I still have a CD with a SP3. Going from VB to Win32
and back can be done, but its always felt odd to me.
I do not even have VB6 on my current Win 11 system.ÿ I do have it on
my Win 7 system behind me.
in the day. I still have some legacy boxes, pentium 4's iirc, that
have my old home/pool inspection system still running.
VB6 is a 32 bit Windows program.ÿ I highly doubt that it will run in
DosBox.ÿ Maybe VB5 is a Win16 program?
On 11/18/2026 6:22 PM, Lynn McGuire wrote:
On 11/18/2026 4:53 PM, Chris M. Thomasson wrote:Sure it (VB6) can. You can install say, winxp, or whatever on a hd image
...
The little shit can run in dosbox. I had it on winnt, me and xp backAll of my calculation software is currently Win32 DLLs so my
customers can easily use them for custom calculations.
Well, that should work fine. Once they know the API, anybody
should be able to use them. Iirc, it was a little strange to map >>>>>>> DLL's created in C to the VB 6 data types. But, can be done for >>>>>>> sure.
VB6 SP5 IIRC.
Nice. I think I still have a CD with a SP3. Going from VB to Win32
and back can be done, but its always felt odd to me.
I do not even have VB6 on my current Win 11 system.ÿ I do have it on
my Win 7 system behind me.
in the day. I still have some legacy boxes, pentium 4's iirc, that
have my old home/pool inspection system still running.
VB6 is a 32 bit Windows program.ÿ I highly doubt that it will run in
DosBox.ÿ Maybe VB5 is a Win16 program?
in dosbox... Boot it up. Install VB6. Create a hello world program, run it.
For example, it does not[...]
matter if they refer to a constant 1234 as an "integer literal" (the
term in C23 and C++, IIRC), an "integer constant" (the term in C prior
to C23), or non-standard but obvious terms like a "literal int" or
"explicit integer in the source code".
In article <11dla8a$1p00u$2@kst.eternal-september.org>,
Keith Thompson <Keith.S.Thompson+u@gmail.com> wrote:
Ross Finlayson <ross.a.finlayson@gmail.com> writes:
[...]
About Wittgenstein, people studying logic & history oftenphilosophy.
arrive at the profundity of the "Tractatus Logicophilosophicus",
which by its name is a worked-over work about logic and
[...]
Please stop.
If I may, I suspect the best way to get him to stop is to
ignore.him.
- Dan C.
David Brown <david.brown@hesbynett.no> writes:
[...]
For example, it does not[...]
matter if they refer to a constant 1234 as an "integer literal" (the
term in C23 and C++, IIRC), an "integer constant" (the term in C prior
to C23), or non-standard but obvious terms like a "literal int" or
"explicit integer in the source code".
C23 still uses "integer constant". The C2y drafts change that to
"integer literal".
| Sysop: | Tetrazocine |
|---|---|
| Location: | Melbourne, VIC, Australia |
| Users: | 3 |
| Nodes: | 8 (0 / 8) |
| Uptime: | 11:17:27 |
| Calls: | 222 |
| Files: | 21,513 |
| Messages: | 85,351 |