News for hackers. Stuff that matters.
Re:Prefer duplication over the wrong abstraction by jbooth on Saturday July 09, 2016 @02:12PM (#12062558)
Agree with all of that. My hatred of extreme DRY is due to having been burned by premature/poor abstraction so many times.

Also, there are even exceptions to that rule.. I've seen a number of cases, let's say you've got a bunch of command line utilities that launch different jobs, there's some code that's duplicated across like 10 of them. Be careful with deduplicating that, you can wind up forcing very different things to pretend they're the same.

To put it another way -- it doesn't make a whole lot of sense to abstract some "forNtimes(closure, N)" function instead of just writing a for loop. There's a limit.. that example is laughable but I've seen a lot of abstractions that actually increase the amount of code in my day.

Re:Prefer duplication over the wrong abstraction by gnaritas on Saturday July 09, 2016 @04:40PM (#12063228)
We're probably in close agreement then. However I'll disagree with your last statement as that's actually often a standard abstraction and the clearer less error prone way to write an n times loop. I'd rather see

    20.timesRepeat(() => doStuff());
than

    for(var x = 0; x<20; x++){
        doStuff();
    }
for and foreach loops are virtually always in need of some cleaner functional abstractions that are already standard parts of virtually every collections library and are far more amenable to chaining. Abstracting loops is not premature abstraction, they're already abstracted in your collections lib.
Re:Prefer duplication over the wrong abstraction by jbooth on Saturday July 09, 2016 @04:54PM (#12063273)
That depends on the language, I love flatMap, but I never want to see functions attached to the integer type. Just stop with that :) Principle of least astonishment and all.
Re:Prefer duplication over the wrong abstraction by gnaritas on Saturday July 09, 2016 @05:11PM (#12063346)
An integer is an object, objects have methods, such methods are standard fare; if it's astonishing, try more languages. This is the idiomatic way to do this for example in Smalltalk.

    10 timesRepeat: [ self doStuff ]
What's relevant isn't whether you're astonished or not, but whether it's idiomatic or not. If you can't see an integer as an object with methods, then you haven't fully grokked OO.
Re:Prefer duplication over the wrong abstraction by jbooth on Saturday July 09, 2016 @06:07PM (#12063551)
I've tried lots of languages, thanks. It's still astonishing and will always be astonishing.

WTF does "timesRepeat" have to do with what an integer represents? Nothing, that's what. Integer is a noun, conventionally a 32-bit value type, while "timesRepeat" is a control structure. It's absolutely crazy for "timesRepeat" to be a member of integer.

http://thecodelesscode.com/case/223

Re:Prefer duplication over the wrong abstraction by gnaritas on Saturday July 09, 2016 @07:43PM (#12063876)
You're completely ignoring what I said, idomatic; this is how it's normally done in Smalltalk, and it's absolutely idiomatic to hang control structures off objects since that's how the entire language is implemented from top to bottom, it's not crazy at all, it's good design that keeps the language itself minimal. As for what #timesRepeat: has to do with Integer, I'd think that's pretty obvious, an object should be able to enumerate itself, to write a loop where you inc a counter is procedural, not object oriented and I'm very much talking about OO here, not procedural programming.

Same thing applies to ranges.

    1 to: 10 do: [:num | Transcript show: num  ]
#to:do: is a control structure on Number of which Integer is a subclass. Anonymous methods even have methods, consider the basic while loop.

    [ aList isEmpty ] whileFalse: [ aList removeFirst ]
#whileFalse: is a control structure on BlockContext, the class represented by [ ]. No, there's nothing weird at all about hanging control structures off of system objects, that's one of the best ways to design a minimal language and avoid the plague of a hundred reserved words that you encounter in C variants.