[TUHS] v7 K&R C

[Dr Iain Maoileoin]

Being Scottish and in the 70s our world was constrained by UK import restrictions - to protect our industries.  As a boy I cut my teeth on a language called Algol68 that ran  on a ICL 1904 (24 bit word and 6 bit byte, generally a capital letter only system!). 
The language was part of my academic course work.

OK it was not a OO language but - in 1968 - it had strict type checking, structures, user-defined types, enums, void, casts, user-defined operators (overloaded) both infix and prefix,  (all defined on a formal mathematical basis giving syntax and semantics)  Together with “environment enquiries”  to find out how big an int was or the precision of a float.

Users could also define their own operators - think about it as no more that strange names of a variable or procedure - and also allocate priority to the various operators in that world (monadics ALWAYS had a priority of 10 and bound tightest).  But it went too far.  You could define (note that the concept of +=  did not exist in the base language in 1968) a new operator such as “+:=“  

op +:= = (ref in a, int b) ref int: a:=a+b;   € It took a pointer to an int, and int and returned the pointer

[Of course you could also define it to be
op +:= = (ref in a, int b) ref int: a:=a-b+7;
]
You could even use Jensen’s device with operators.  If you dont know ALgol68 have a speed read of https://research.vu.nl/ws/portalfiles/portal/74119499/11057

My move to unix and C in the 70s was a huge retro step for me - but I could not develop systems code in Algol68 - for example the transput library was about 8K before your blinked.  Certainly in C we could code more and faster - no type-checking and we had enuf experience of compilers to understand what was going on at the machine code level - we could just drive the I/O registers directly.   

Then C++?  Like microsoft windows I evaluated, tried it a bit and voted the theory good but the smell bad.    I had a few students who wrote in C++ over a few years, but you know what, it did not do anything earth shattering and it could be a b*gger to work on a debug of a 20K line student program!  Like some here I think C++ was just on the wrong side of a line that I dont understand.  Similarly, for me,  perl is on one side of that line and python is far over the other side.

My question is:
What is that line?  I dont understand it?  Effort input vs output?  Complexity measure,  debugging complexity in a 3rd party program?  [I hated assembler too unless it was my own (or good) ;-)]  But machine code was good, few people would do too much in a complicated way writing in binary/octal/hex!


> On 15 May 2020, at 03:44, Rob Pike <robpike at gmail.com> wrote:
> 
> Perhaps for the first time in my career, I am about to disagree with Doug McIlroy. Sorry, Doug, but I feel the essence of object-oriented computing is not operator overloading but the representation of behavior. I know you love using o.o. in OO languages, but that is syntax, not semantics, and OO, not o.o., is about semantics.
> 
> And of course, the purest of the OO languages do represent arithmetic as methods, but the fit of OO onto C was never going to be smooth.
> 
> -rob
> 
> 
> On Fri, May 15, 2020 at 4:42 AM Doug McIlroy <doug at cs.dartmouth.edu <mailto:doug at cs.dartmouth.edu>> wrote:
> > o operator overloading
> >
> > I never could figure out why Stroustrup implemented that "feature"; let's
> > see, this operator usually means this, except when you use it in that
> > situation in which case it means something else.  Now, try debugging that.
> 
> Does your antipathy extend to C++ IO and its heavily overloaded << and >>?
> 
> The essence of object-oriented programming is operator overloading. If you
> think integer.add(integer) and matrix.add(matrix) are good, perspicuous,
> consistent style, then you have to think that integer+integer and
> matrix+matrix are even better. To put it more forcefully: the OO style
> is revoltingly asymmetric. If you like it why don't you do everyday
> arithmetic that way?
> 
> I strongly encouraged Bjarne to support operator overloading, used it
> to write beautiful code, and do not regret a bit of it. I will agree,
> though, that the coercion rules that come along with operator (and
> method) overloading are dauntingly complicated. However, for natural uses
> (e.g. mixed-mode arithmetic) the rules work intuitively and well.
> 
> Mathematics has prospered on operator overloading, and that's why I
> wanted it. My only regret is that Bjarne chose to set the vocabulary of
> infix operators in stone. Because there's no way to inroduce new ones,
> users with poor taste are tempted to recycle the old ones for incongruous
> purposes.
> 
> C++ offers more features than C and thus more ways to write obscure code.
> But when it happens, blame the writer, not the tool.
> 
> Doug
> 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20200515/ed3bf4bd/attachment.htm>