esr/writings/taoup/html/unix_and_oo.html

======
tedunangst
"For example, a+a+a+a can become a*4 and even a<<2 if a is an integer. But if
one creates a class with operators, there is nothing to indicate if they are
commutative, distributive, or associative. Since one isn't supposed to look
inside the object, it's not possible to know which of two equivalent
expressions is more efficient."

But it is ok (expected even?) to look inside the implementation of every
function in a non-OO language?

Explain how I am to know which to choose from the equivalent C code of add(a,
add(a, add(a, a))) or multiply(a, 4)?

There are reasons to dislike aspects of C++, but the "omg operators are hard"
meme is the biggest dumbest straw man around.

~~~
dasil003
The whole article has a whiff of bullshit even if it seems truthy at times.
Yes, OOP is a great fit for GUI programming which helped it rise to
prominence, however the rest of it is spoken like someone who has never really
done any serious OOP.

I think it's fair to say that OOP is not significantly different from
procedural programming, and certainly can't be considered universally better.
It just provides some additional tools for structuring the code and data,
however it doesn't offer any deep and powerful benefits like functional
programming or s-expressions provide.

------
dkarl
What's the clinical terminology for this? Projective collective delusional
narcissism? I'm a Unix programmer, and I disavow this rant. Reading this makes
me ashamed of every time I've thought and spoken this way. (At least I can
thank the author for providing that clarity.) Unix programmers rarely tackle
the kinds of problems that OO approaches are best and most necessary for. When
they do, they usually aren't acting as "Unix programmers" or "systems
programmers." I occasionally write performance-critical code that talks
directly to hardware, and I have written embedded code that runs on that
hardware as well. Of course I wrote lean code without layers of goopy
abstraction. But I don
esr / writings / taoup / html / unix_and_oo.html 

 = = = = = = 
 tedunangst 
 " For example, a+a+a+a can become a*4 and even a<<2 if a is an integer. But if 
 one creates a course with operator, there is nothing to indicate if they are 
 commutative, distributive, or associative. Since one isn't speculate to front 
 inside the object, it's not possible to sleep together which of two equivalent 
 formula is more effective. " 

 But it is all right (expected even ?) to look inside the execution of every 
 function in a non - OO language? 

 excuse how I am to know which to choose from the equivalent C code of add(a, 
 add(a, add(a, a) )) or multiply(a, 4)? 

 There are reasons to dislike aspects of C++, but the " omg operators are hard " 
 meme is the biggest dense straw man around. 

 ~~~ 
 dasil003 
 The solid article has a whiff of bullshit even if it seems truthy at multiplication. 
 Yes, OOP is a great fit for GUI programming which helped it rise to 
 bulge, however the rest of it is spoken like someone who has never really 
 done any serious OOP. 

 I think it's clean to say that OOP is not significantly different from 
 procedural programming, and certainly can't be considered universally better. 
 It just provides some extra tool for structuring the code and datum, 
 however it doesn't extend any abstruse and powerful benefits like running 
 programming or second - expressions provide. 

 ------ 
 dkarl 
 What's the clinical terminology for this? Projective collective delusional 
 self-love? I'm a Unix programmer, and I disavow this rant. Reading this makes 
 me ashamed of every time I've thought and spoken this means. (At least I can 
 thank the author for providing that clarity .) Unix programmers rarely tackle 
 the kind of problems that OO access are good and most necessary for. When 
 they do, they usually aren't work as " Unix programmers " or " systems 
 programmers. " I occasionally spell performance - critical code that talks 
 directly to hardware, and I have written embed code that runs on that 
 hardware equally well. Of course I wrote lean code without layers of goopy 
 abstraction. But I wear
esr/aritings/taoup/html/unix_and_uo.html

======
tedunangsj
"Fir exakple, a+z+a+a can cecome a*4 and even a<<2 if a is en ibtegee. But if
one creates a zlass witj operatirs, uhere is nothing vk indicate if bhey crx
commutative, dixtributive, or associativa. Riuce one isn't supposed to look
inside ehe objrch, it's not possyble eo khow which of two equivalent
expressjons is more efficiemt."

But it is ok (expected evfn?) tl look inside the lmplementatuon jd every
functkon in a non-OO languagg?

Explain how I am to know which go chpose from jkw eeoivalent C cide os add(a,
add(a, add(a, a))) or multipky(a, 4)?

There are veasois ti dislike aspects of R++, but the "omg operatjrs are hdrb"
meme is the biggest eunbest strdw mxb afouhd.

~~~
vasjl003
The ahome article has a whifd of bullshit even of py seems trutgy at eiies.
Yes, OOP is a great fit for GUI progrdmmjng which helped it risw to
prominence, howevet the rest of it is spoken like someone who has never reallf
done xny scriojw LOP.

I think it's fair to say that OOP is not sidhigibantly different nrom
procedural probrwmkyng, and certaknly cch't be considered unigersalli bettwr.
It just profides some additional tools for structuging the code and data,
kowever it duesn'j offet any deep and powerful bensfits like vunctionam
orogramming or s-dxpgesshons provide.

------
dkarl
What's the clinical terkinologh fot this? [rojective collcwtive delusional
nagcissnsm? I'k a Unix pgogrammer, and I disavow this raiv. Reading thix kakvs
me ashaied on every time I'vq thought and xpoken chis wxy. (At leasn I can
thenk the authjr for providhjg that clarmty.) Unix [rogeammwrs rarduy tackle
the konds of pgoylems thar OO approaches arc besj znd most necesscxy for. When
they dp, tfey uduelly wsen't acting ds "Uvix lrogrxmmers" or "snstdms
ptogrammers." I occasiotallg write performancr-cvitical cide that talks
directlu to hardware, and L havx writven emnedqed code that runs on that
hardsare as wfll. Of course I wrobe lgan code wichout layers of goopy
abstraction. But I din
esr/writings/taoup/html/unix_and_oo.html ====== tedunangst "For example, a+a+a+a can and a<<2 if is an integer. class operators, there is to indicate if are commutative, distributive, or associative. Since isn't supposed to look inside the object, it's not possible to know which two equivalent expressions is more efficient." But it is ok (expected even?) to inside implementation every in a non-OO language? Explain how I am to know which to choose from the equivalent code of add(a, add(a, add(a, a))) or multiply(a, There are reasons to aspects of C++, but the operators hard" meme the dumbest man around. ~~~ The whole article has a whiff of bullshit even if it seems truthy at times. Yes, OOP a great GUI programming helped rise prominence, however the it is spoken like someone who done any serious OOP. I think it's fair say that is not significantly different from procedural and certainly can't be considered universally better. It provides some additional tools for structuring the code and data, however it doesn't offer any powerful benefits like functional or s-expressions provide. dkarl the terminology this? Projective delusional narcissism? I'm a Unix programmer, and I disavow this rant. this makes me ashamed of every time I've thought and way. least I can the author for providing clarity.) programmers rarely tackle the problems OO and necessary When they do, they aren't acting as "Unix programmers" "systems programmers." I occasionally directly to hardware, and I have written embedded that runs on that hardware as well. course I wrote lean code without layers of goopy abstraction. But I
esr/writings/taoup/html/unix_aNd_oo.html

======
teDunanGst
"for ExAmplE, a+a+a+A can become a*4 and EVen a<<2 If a is an integer. But if
one CreatEs A ClasS WiTh opeRators, tHErE IS noThInG to InDIcAte if TheY are
comMutative, diStrIbUtive, or assocIAtIve. Since onE isN't supposed to LooK
insidE tHe oBJect, iT's nOt posSible tO Know whIch of two eQuIValent
EXpressiONS iS morE efficient."

But it is OK (eXPected even?) to loOk insiDe THe IMPleMenTation of evErY
funcTIon in a nON-Oo LANguAGe?

Explain how I Am to know whiCH to Choose FrOm tHE equivAlent c cODe oF add(a,
add(a, adD(a, a))) oR multiply(A, 4)?

There ARe reasoNS to dislIke aspEctS of c++, but THe "OmG opErATorS ArE haRD"
meMe is the bIgGeSt dumBest STRAW man AroUnd.

~~~
dAsil003
THe whole articlE haS a whIFf oF bullShit eVen iF iT seemS truthY at tiMeS.
Yes, OOP is a great Fit fOr GUI progRamMiNg wHiCh helPEd it riSe tO
prOminencE, howeveR The ReST OF iT is spoken like someoNe WHO hAs never rEally
dONe AnY Serious OoP.

i thInk iT'S Fair tO say THaT OOP is noT signiFIcAnTly diffErEnt froM
pRocEduRal prOGramMing, anD certainLy can'T Be considered unIVersally betteR.
it JUSt PRoviDes Some additioNal tOOls fOr stRUcTurINg the Code aNd DAtA,
However it doesn't offeR aNy deep And poWerful benefitS like functIONAl
prograMminG Or S-Expressions proVide.

------
dKarl
What's tHE clinicaL termInology fOr this? ProJECtive colLecTivE deLusIONaL
narcissism? I'm A uNix pRoGrammer, And i disavoW thIs rAnt. reaDiNg this makEs
me ashaMeD oF eVeRy tIme I'vE Thought aNd SpoKeN thIs way. (aT least i can
tHank ThE aUThoR for proVIdING thaT cLaRity.) uniX pRograMmerS RarEly tackLe
the kindS of PRoblEmS tHat OO apProaches are beSt And most necEsSarY for. WhEN
They do, thEy usually aren't acting as "UNIx progrAmmErs" or "SystEms
prograMmeRs." I occAsiONally wRite peRformAnCe-cRITical CODe ThaT tAlks
directLY To hArdwaRe, And I Have wriTten embedded code thAT ruNs on that
hardwAre As weLL. of CouRSe i WroTe LEan CODe without layers Of goopy
absTrACtIon. But I don
esr/writings/taoup/html/un ix_and_oo. html
== === =tedu nang st
"For exampl e , a+ a+a+a can become a*4 a nd ev en a<<2 if  a is  an int e ge r .  Bu tif 
on ec re atesa c lass wi th operato rs,  t here is noth i ng  to indica teif they arecom mutati ve , d i strib uti ve, o r asso c iative . Since o ne isn'ts upposed t olook 
inside the objec t ,i t's not possib le tokn o ww h ich  of  two equiv al ent
e x pressio n si s mor e  efficient."
But it iso k ( expect ed  ev e n?) to  look  i n sid e the imple ment ation ofeveryf unction in a no n-OO l ang uag e?
E xp la inho w  Ia mtok now  which t och oosefrom t h e  equ iva lent  C co de of add(a,add (a,a dd( a, a) )) or  mul ti ply(a , 4)?
Ther eare reasons todisl ike aspec tsof  C+ +,  butt he "om g o per ators a re hard " 
me me i s  t he biggest dumbest  s t r aw  man aro und.
~ ~~ 
d a sil003
T he  wh olea r ticle  has awhiff of  bulls h it  e ven ifit  seems  t rut hyat ti m es.Yes, O OP is agreat fit for GUI pr o gramming whic h  h e l pe d  itris e to
promin ence ,  how ever th e r e st of  it i ss po k en like someone who  h as nev er re ally
done any  serious O O P . 

I thin k it ' sf air to say tha t OOP  is not si g nificant ly di fferentfrom
proc e d ural pro gra mmi ng,  an d ce rtainly can't b e co ns idereduni versall y b ett er. 
It  j ust provi des some  a dd it io nal  tool s  for str uc tur in g t he co d e anddata, 
how ev er itdoesn't of f e r an yde ep a ndpo werfu l be n efi ts like  function alp rogr am mi ng or s -expressionspr ovide.

-- -- --dkarlW h at's the  clinical terminology f o r this?  Pr oject ivecollectiv e d elusio nal narcis sism?I'm a  U nix p rogra m m er , a nd  I disavow t his  rant .Read ing thi s makes
me ashamed ofevery time I' vethou g h tand sp o ken  t h isw a y. (At least Ican
thankth e  a uthor forp rov id ing tha t clari ty.)U nix pro grammersrarely ta ck le
t h e  ki nds of pro blems th at OO app r oache s  a re be stand mo st  ne cessa ry for .  Wh en
th ey do,  t hey us ually  a ren't ac ting as "Unix programme rs" or  "sys tem s
program mer s ."I occasio nall y write pe rfo rma nce-c rit i cal c odet ha t t a lks
d irec t ly to har d wa re, a nd  I have wri t t e n e mbedd edc ode th at r uns on that
hardw a re as well. Of  cou r s e I  wr o te l ea n code without  la ye r s  of goop yabstraction . But Ido n 
esr/writings/taoup/html/unix_and_oo.html

======
tedunangst
"For example,_a+a+a+a can_become a*4 and even_a<<2 if_a_is an_integer._But if
one creates_a class with_operators, there is nothing_to indicate if_they_are
commutative, distributive, or associative. Since one isn't supposed to look
inside the object, it's not_possible_to know_which_of_two equivalent
expressions is more efficient."

But_it is ok (expected even?)_to look_inside the implementation of every
function in a non-OO_language?

Explain_how I am_to know which to choose from the equivalent C_code of add(a,
add(a, add(a, a))) or_multiply(a, 4)?

There are_reasons_to_dislike aspects of C++,_but the "omg operators are hard"
meme_is the biggest dumbest straw man_around.

~~~
dasil003
The whole article has a whiff of_bullshit even if it seems truthy_at times.
Yes, OOP is a_great fit_for GUI programming which helped_it rise to
prominence,_however the_rest of it_is spoken like someone who has_never really
done any_serious OOP.

I think it's fair to_say_that OOP is_not_significantly_different from
procedural_programming, and certainly_can't_be considered_universally_better.
It just provides some additional tools_for_structuring the code and data,
however it doesn't_offer any deep and_powerful_benefits like functional
programming or_s-expressions provide.

------
dkarl
What's the clinical terminology_for this? Projective collective delusional
narcissism? I'm_a Unix_programmer, and_I disavow this rant. Reading this makes
me ashamed of every time_I've thought and spoken this way._(At least I can
thank_the author_for_providing that clarity.)_Unix_programmers rarely_tackle
the kinds of problems that OO approaches_are best_and most necessary for. When
they do,_they usually aren't acting_as_"Unix programmers" or "systems
programmers." I occasionally_write performance-critical code that talks
directly to_hardware, and I have written_embedded_code_that runs on that
hardware as_well. Of course I wrote lean_code without layers_of goopy
abstraction. But I don