News for hackers. Stuff that matters.
Re:The Humble Programmer by wavegeek on Thursday August 06, 2015 @02:36AM (#10014904)
Warning: this article is by Dijkstra.

You may remember him as the person after whom the unit of arrogance, the nanoDijkstra, is named.

Re:The Humble Programmer by emirozer on Thursday August 06, 2015 @03:59AM (#10015146)
Dutch directness has a side effect of coming across as arrogant, its merely a difference in culture[0].

For example, if you are Dutch and your friends are Dutch, you don't go on and ask "how are you?" to the people that aren't close to you.

The question "how are you?" is actually there for you to show genuine interest in someone else's life at that moment. The polar opposite of it is the US version i guess, where a "how are you?" results almost always with a "fine and you?".

On another note, i think the main reason(i might be very wrong here) that they had this clash is Alan Kay being a pioneer in object oriented programming. And Dijkstra's counter-discourses against it and sometimes those discourses were harsh[1]. (Although we can agree oop is garbage :D, that is certainly not the best way to put it.)

[0]: Although i have met some Dutch people that were being rude and trying to cover it with "Directness"

http://www.iamexpat.nl/read-and-discuss/expat-page/articles/...

[1]: http://harmful.cat-v.org/software/OO_programming/

Re:The Humble Programmer by nnq on Thursday August 06, 2015 @06:47AM (#10015642)
> Although we can agree oop is garbage :D

Can we? The stuff that Alan Kay put forward in Smalltalk, with message-passing, polymorphism, late binding etc.... was definitely NOT garbage imho!

What C++ an Java and all the all the languages that tried to copy them, and also Javascript with its prototypal inheritance ended up with... it stinks indeed.

But where Scala on one side, and Go and Rust on the other are going... that will be interesting at least :)

Maybe Odersky is on to something with his whole "functional and oo are orthogonal" thing... though the way macros are implemented in Scala on top of and USING the oo core instead of separate and serving as the foundation for oo (CL style) makes me wanna puke when reading the resulting code...

Re:The Humble Programmer by vezzy-fnord on Thursday August 06, 2015 @11:06AM (#10016941)
Indeed, OO hatred is usually a sign of an inexperienced functional programmer.
Re:The Humble Programmer by Lawtonfogle on Thursday August 06, 2015 @11:59AM (#10017366)
Hatred of most any language or set thereof is often a sign of inexperience. The only exceptions I can think of are production use of most joke/esoteric languages and Oracle Forms.
Re:The Humble Programmer by MichaelGG on Thursday August 06, 2015 @12:55PM (#10017765)
Doesn't this mean that anything in production is beyond "hatred"?
Re:The Humble Programmer by haxeny1 on Thursday August 06, 2015 @12:22PM (#10017540)
Smalltalk was a great start, though, that should not have been the benchmark for implementing object oriented languages. There are some valid concerns about oo that were imo missing in mainstream languages such as Java/C++: uniform access principle (scala provides for that, but scala is a different type system) pre-conditions/postconditions as part of core language rather than annotated comments. weaker/stronger pre-conditions/postconditions in derived classes : this makes the use of methods quite obvious and what features are being inherited from the parent class. selective exports of features (this is a less known feature but can save a developer many a times). Repeated inheritance/multiple inheritance implemented right (so diamond hierarchies should be handled without having to resort to any ambiguities). Genericity (templates that understood hierarchy: this was missed in C++ at least in 2001. I havent programmed in C++ since then) Covariance (this was a direct side effect of method inheritance and I found it to be useful).

Without these features and many other features (I borrow this list from Bertrand Meyer's OOSC, 2nd edition), language compilers tend to shift the burden from the compiler to the programmer to manage types etc. It is probably too late to go back to Eiffel, though, I still think that it even today is far ahead of most oo languages, so if folks feel strongly against oo, I can understand that to some extent.

I recall a small exercise,where I was modeling Matrix using integers to do some basic addition and multiplication in Eiffel. It worked the code compiled, tested, assertions validated etc. All good. But how about determinants (I forgot the exact computation that needed that). I was still programming in java at my work and had that sinking feeling of change code at few places to make things Float and (read them as objects instead of primitives etc..you know the drill). It turned out, that the Number hierarchy in Eiffel was quite refined, I changed the declaration at one place and everything worked as expected. This was a small exercise, though it clearly outlined the power of the language.

As an aside, there was another feature that ensured that floating point numbers weren't being allocated on a heap: it was a keyword : Expanded: implying no references are created for the expanded objects. This feature alone can save a ton when decoding objects from a network etc, without me, the developer, having to worry about boxing/unboxing and the subsequent performance implications.

So, yes, OO was/is a great paradigm, though it is the details of implementation that matter. When I used to attend job interviews and was faced with one of the canned questions: which is better Java or C++, I started to take the "fifth" because I could not in all honesty compare truly bad implementations of the oo paradigm. The only reason I started to briefly look up scala was because Martin Odersky used Eiffel as one of his references : Uniform Access Principle to implementing the Scala type system. But that is as far as I could go, because, after looking at OCAML, it hit me that oo and functional can't safely mix.

Re:The Humble Programmer by jimmaswell on Thursday August 06, 2015 @11:10AM (#10016974)
OOP is anything but garbage. It's extremely productive for GUIs, gamedev, lots of things. Don't be ridiculous. It's a shame it's "hip" to pretend it's awful around here.
Re:The Humble Programmer by tajen on Thursday August 06, 2015 @02:40AM (#10014911)
Re:The Humble Programmer by ak39 on Thursday August 06, 2015 @03:52AM (#10015116)
Probably originally attributed to Alan Kay: https://en.wikiquote.org/wiki/Talk:Edsger_W._Dijkstra

Quote: I found an amusing quote from Alan Kay on Dijkstra, from his 1997 OOPSLA keynote: 'I don't know how many of you have ever met Dijkstra, but you probably know that arrogance in computer science is measured in nano-Dijkstras.' [audience laughter][1]. --24.184.131.16 20:06, 16 March 2008 (UTC)

https://www.youtube.com/watch?v=Xoyw8LHGtzk

Re:The Humble Programmer by spacecowboy_lon on Thursday August 06, 2015 @09:21AM (#10016179)
I used to work at BT with a (very good) DBA who's first boss was Dijkstra
Re:The Humble Programmer by myhf on Thursday August 06, 2015 @04:08AM (#10015181)
Hmm, for some reason it won't let me convert Stephen Wolfram to nanoDijkstras.
Re:The Humble Programmer by jhdevos on Thursday August 06, 2015 @05:25AM (#10015391)
Integer overflow?
Re:The Humble Programmer by gjm11 on Thursday August 06, 2015 @06:59AM (#10015675)
Unlikely; Wolfram Alpha is based on Mathematica, which has arbitrary-precision integers, and I don't think one wolfram can be more than about 10^12 nano-dijkstras.

(If I put "1 wolfram" into Alpha then it tells me about Stephen Wolfram. If I put "2 wolfram" into Alpha it tells me about tungsten. I guess that when you ask it for "1 whatever", it first simplifies it to "whatever", and then you can have variable quantities of tungsten but not of Stephen Wolfram.)

Re:The Humble Programmer by nnq on Friday August 07, 2015 @03:04AM (#10021238)
Wolfram is also another name for the chemical element "tungsten" https://en.wikipedia.org/wiki/Wolfram_(element) ("2 wolfram" probably means "give me the second meaning of 'wolfram'"). Mathematica/WolframAlpha is probably not smart enough to figure out unambiguously how much mass or energy could be in one nano-dijkstra, which it would need for such a conversion.

On the other hand, referring to "1 wolfram", some would argue that one wolfram could greatly exceed 10^12 nano-dijkstras... Dijkstra was actually quite smart and from reading his essays, I'd consider him quite humble, not arrogant at all.

He had that "old-noble-European cold-joking-seriousness" and most Americans are known to be incapable of understanding this tone of communication.

Re:The Humble Programmer by SZJX on Friday August 07, 2015 @12:05PM (#10023225)
Don't know him a lot, but this sounds credible just from this article:

> The first effect of teaching a methodology —rather than disseminating knowledge— is that of enhancing the capacities of the already capable, thus magnifying the difference in intelligence.

Only an arrogant person would assume his success is down to his being intellectually superior than his peers instead of him enjoying a wealth of resources along the path of growing up and maybe some hard work + luck.