08:40 <moo> I am so confused. [1,2,3].bsearch{|x| x>=1} => 1 while [1,2,3].bsearch{|x| x==1} => nil ??

08:43 <leah2> you cant bsearch with ==

08:44 <moo> oh i thought it just looks for true/false there :3 thanks

08:48 <leah2> it needs to be monotonic

08:48 <moo> oh heh it seems Array-Array is still plenty fast and i should just do that

08:48 <leah2> jus tuse find

08:48 <leah2> or that

08:49 <moo> at first i made arr.reject!{|x| !arr2.index(x).nil? } and that was probably the worst way to do it haha

08:59 <leah2> hehe

14:17 <nakilon> my coworker is misunderstanding the purpose of the methods/functions

14:19 <nakilon> 1. he roleplays the winrar and when sees a line of code that is repeating several times he hurries to define a method that will be one line long, saying "it's simplifying the code, because we had the same thing repeated in multiple places", so now instead of repeating some obvious code we are going to STILL REPEAT but not the obvious thing but his cryptic method name?

14:20 <nakilon> and 2. even if the thing isn't repeated anywhere and is called only once and will be so for the whole 21st century in the codebase he anyway goes to define a method "because we define methods like this" ("we define" -- he means his own idea from the (1)

14:22 <nakilon> in my 20 years of coding experience I know from long ago that many things that are hiding by different "pattern" names are often just the same thing, and the whole purpose of functions by the damn definition of the word is to DRY the things; functions are to move something to a single place only due to two reasons:

14:23 <nakilon> a) the stuff may change and to not forget to edit some of the multiple places we put the changeable thingy into a constant (or single literal method, it all depends on the language syntax, etc.) to edit it in one place if it ever will be needed

14:24 <nakilon> b) if the repeating thing is a multiline block; so it takes more lines to read and proportionally increases the chance to forget or miss some detail

14:26 <nakilon> but he sees `get("user/documents")` and defines a user.documents and who the hell is gonna know what that means? is that a GET or POST? is that a REST at all?! maybe that's an attribute? he hides a place that unlike other lines of code is a network request, i.e. slow, error-prone, etc., saying it "makes code more readable" -- hell no, who knows what that method does? noone

14:27 <nakilon> -- the DRY is not applicable here, it does not save us any lines, because it's being called only once and you just have hidden the implementation

14:28 <nakilon> -- we should not reduce the number of lines, we should make the code readable

14:29 <nakilon> dude, you literally have hidden the implementation -- how does it make it readable? you say "the REST api urls are named stupidly, my names are better" -- what? it is so subjective, the whole fact of thinking just renaming things is a needed thing

14:31 <nakilon> and no, we SHOULD reduce the number of lines, because the amount of errors is proportional to it; dude just does not know how to code, and it frustrates be, because the boss is gonna decide that the issue is in me because that's the best dude they possess to help me with the project; but defining layers of methods for a single call from another file is not a help

14:31 <nakilon> *frustrates me

14:32 <nakilon> idk how to make him accept my rules

14:37 <nakilon> the `user.documents` is by no means "more readable" than `user.get("user/documents")`; it is just a lie; it is a result of some broken way to think

14:43 <kjetilho> nakilon: if there is just one reference to it, fine. if there are multiple, `user.documents` can catch typos (`user.douments`) lexically but `get("user/douments")` can only be discovered during runtime

15:32 <nakilon> kjetilho: nice point, though I doubt anyone in my company has a language server to detect typos; will Rubymine see it?

15:33 <nakilon> and we have CI anyway, so the typo does not create a business-logic error and will be caught anyway

15:38 <nakilon> I mean, in my opinion the code structure should help building programs with correct logic, not solve the issues that otherwise would be spotted if Ruby was compilable

19:00 <o0x1eef> I'm not sure I think 'user.documents' is an anti-pattern tbh. I can see benefits with that approach. Still, if everything is a method it just adds a layer of indirection that can make code harder to follow, it depends how widespread it is