kurko__ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
marr has quit [Ping timeout: 240 seconds]
schneider has joined #ruby
Asher has quit [Quit: Leaving.]
cadillac_ has quit [Ping timeout: 240 seconds]
schneider has quit [Ping timeout: 264 seconds]
cadillac_ has joined #ruby
tolerablyjake has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Creatornator has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
tolerablyjake has joined #ruby
mroutis_ has quit [Read error: Connection reset by peer]
mroutis has joined #ruby
schneider has joined #ruby
ryzokuken has joined #ruby
s3nd1v0g1us has quit [Remote host closed the connection]
schneider has quit [Ping timeout: 265 seconds]
schneider has joined #ruby
ramfjord has quit [Ping timeout: 260 seconds]
schneider has quit [Ping timeout: 255 seconds]
yukai has joined #ruby
schneider has joined #ruby
Creatornator has joined #ruby
Yxhuvud has quit [Quit: No Ping reply in 180 seconds.]
schneider has quit [Ping timeout: 256 seconds]
herbmillerjr has quit [Quit: Konversation terminated!]
Yxhuvud has joined #ruby
gizmore|2 has joined #ruby
schneider has joined #ruby
ogres has quit []
gizmore has quit [Ping timeout: 260 seconds]
liam___ has joined #ruby
cyberg has quit [Quit: Leaving]
liam___ is now known as lelliott
schneider has quit [Ping timeout: 260 seconds]
schneider has joined #ruby
schneider has quit [Ping timeout: 260 seconds]
ramfjord has joined #ruby
ogres has joined #ruby
ogres has quit [Client Quit]
schneider has joined #ruby
woodruffw has joined #ruby
schneider has quit [Ping timeout: 240 seconds]
s2013 has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
Yxhuvud has quit [Quit: No Ping reply in 180 seconds.]
schneider has joined #ruby
lelliott has quit [Remote host closed the connection]
Yxhuvud has joined #ruby
adjustingmaitai has joined #ruby
dinfuehr has quit [Ping timeout: 255 seconds]
nicesignal has quit [Remote host closed the connection]
nicesignal has joined #ruby
dinfuehr has joined #ruby
schneider has quit [Ping timeout: 264 seconds]
schneider has joined #ruby
Asher has joined #ruby
agent_white has joined #ruby
schneider has quit [Ping timeout: 255 seconds]
n0m4d1c has joined #ruby
Yxhuvud has quit [Quit: No Ping reply in 180 seconds.]
tolerablyjake has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Yxhuvud has joined #ruby
s2013 has joined #ruby
ramfjord has quit [Ping timeout: 265 seconds]
mroutis has quit [Read error: Connection reset by peer]
schneider has joined #ruby
mroutis_ has joined #ruby
bmurt has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ur5us_ has quit [Remote host closed the connection]
ur5us has joined #ruby
skweek has joined #ruby
schneider has quit [Ping timeout: 240 seconds]
ur5us has quit [Ping timeout: 260 seconds]
schneider has joined #ruby
ramfjord has joined #ruby
Yxhuvud has quit [Quit: No Ping reply in 180 seconds.]
Yxhuvud has joined #ruby
eckhardt has quit [Ping timeout: 256 seconds]
schneider has quit [Ping timeout: 260 seconds]
ur5us has joined #ruby
NorthLumberJack has joined #ruby
ramfjord has quit [Ping timeout: 264 seconds]
schneider has joined #ruby
ramfjord has joined #ruby
noobineer has quit [Ping timeout: 260 seconds]
schneider has quit [Ping timeout: 265 seconds]
schneider has joined #ruby
ramfjord has quit [Ping timeout: 260 seconds]
arescorpio has joined #ruby
schneider has quit [Ping timeout: 265 seconds]
Yxhuvud has quit [Quit: No Ping reply in 180 seconds.]
schneider has joined #ruby
s2013 has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
alfiemax has quit [Ping timeout: 240 seconds]
Yxhuvud has joined #ruby
Psybur has quit [Ping timeout: 260 seconds]
cadillac_ has quit [Quit: I quit]
cadillac_ has joined #ruby
schneider has quit [Ping timeout: 260 seconds]
imode has quit [Ping timeout: 260 seconds]
schneider has joined #ruby
ramfjord has joined #ruby
agent_white has quit [Remote host closed the connection]
Yzguy has quit [Quit: Zzz...]
schneider has quit [Ping timeout: 255 seconds]
sungard has quit [Ping timeout: 260 seconds]
n0m4d1c has quit [Remote host closed the connection]
alfiemax has joined #ruby
schneider has joined #ruby
schneider has quit [Ping timeout: 264 seconds]
Yzguy has joined #ruby
\void has quit [Quit: So long, and thanks for all the fish.]
schneider has joined #ruby
Yxhuvud has quit [Quit: No Ping reply in 180 seconds.]
gix has joined #ruby
Creatornator has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Yxhuvud has joined #ruby
mroutis_ has quit [Read error: Connection reset by peer]
mroutis has joined #ruby
schneider has quit [Ping timeout: 264 seconds]
skweek has quit [Ping timeout: 260 seconds]
gix- has quit [Ping timeout: 260 seconds]
Yxhuvud has quit [Client Quit]
erlend has joined #ruby
schneider has joined #ruby
Yxhuvud has joined #ruby
cibs_ is now known as cibs
schneider has quit [Ping timeout: 264 seconds]
schneider has joined #ruby
mroutis has quit [Ping timeout: 276 seconds]
Creatornator has joined #ruby
Puffball has joined #ruby
schneider has quit [Ping timeout: 260 seconds]
n0m4d1c has joined #ruby
jenrzzz has joined #ruby
jenrzzz has quit [Changing host]
jenrzzz has joined #ruby
schneider has joined #ruby
Yxhuvud has quit [Quit: No Ping reply in 180 seconds.]
Yxhuvud has joined #ruby
n0m4d1c has quit [Ping timeout: 240 seconds]
schneider has quit [Ping timeout: 240 seconds]
Yxhuvud has quit [Client Quit]
Yxhuvud has joined #ruby
arescorpio has quit [Excess Flood]
r3m has quit [Ping timeout: 276 seconds]
schneider has joined #ruby
s2013 has joined #ruby
jenrzzz has quit [Ping timeout: 265 seconds]
r3m has joined #ruby
Creatornator has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
schneider has quit [Ping timeout: 255 seconds]
shakes has joined #ruby
donofrio has quit [Remote host closed the connection]
dviola has quit [Quit: WeeChat 2.1]
kapil___ has joined #ruby
schneider has joined #ruby
govg has joined #ruby
schneider has quit [Ping timeout: 256 seconds]
imode has joined #ruby
schneider has joined #ruby
tdy has joined #ruby
NorthLumberJack has quit [Ping timeout: 260 seconds]
schneider has quit [Ping timeout: 260 seconds]
s2013 has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
ramfjord has quit [Ping timeout: 260 seconds]
houhoulis has quit [Remote host closed the connection]
schneider has joined #ruby
law has joined #ruby
<law>
hey all, is there a standard way to tell resque to write files with a certain chmod or umask?
<law>
I've got a legacy job that wants to write files out with '600' permissions by default, and I can't seem to find the knob to twiddle to change that to '644'
schneider has quit [Ping timeout: 240 seconds]
cschneid_ has joined #ruby
schneider has joined #ruby
asif has joined #ruby
orbyt_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
asif has quit [Client Quit]
stairmast0r has quit [Quit: bye]
ramfjord has joined #ruby
stairmast0r has joined #ruby
schneider has quit [Ping timeout: 260 seconds]
schneider has joined #ruby
sundhell_away is now known as sundhell
jenrzzz has joined #ruby
jenrzzz has quit [Changing host]
jenrzzz has joined #ruby
schneider has quit [Ping timeout: 240 seconds]
Asher has quit [Quit: Leaving.]
schneider has joined #ruby
Asher has joined #ruby
cschneid_ has quit [Remote host closed the connection]
<Bish>
that's what i thought, but now thinking about it doesn't make sense
<tbuehlmann>
it's not an "instance" instance variable, it's a "class" instance variable
<Bish>
i get that, i was just confused
<tbuehlmann>
it belongs to T (or its singleton class, if you will), not any instance of T and not any of T's subclasses
<phaul>
the instance's class's singleton class's instance :D
suk has quit [Quit: Leaving]
schneider has quit [Ping timeout: 260 seconds]
karapetyan has quit [Remote host closed the connection]
<Bish>
but to get around the xy problem
<Bish>
i want to have a instance variable for the singleton class
<Bish>
and initialize it inside class << self
<Bish>
but if i do it inside there, it does not seem to be accessbile from the methods i created inside class << self
exchgr has quit [Ping timeout: 240 seconds]
<tbuehlmann>
have a minimal example?
<Bish>
>> class T; class << self;@intervals = {}; def test;@intervals[1]=3;end;end; T.test;
<Bish>
>> class T; class << self;@intervals = {}; def test;@intervals[1]=3;end;end; T.test;
<ruby[bot]>
Bish: # => /tmp/execpad-51c15bd78483/source-51c15bd78483:7: syntax error, unexpected end-of-input, expecting ke ...check link for more (https://eval.in/986178)
<Bish>
damnot!
<Bish>
>> class T; class << self;@intervals = {}; def test;@intervals[1]=3;end;end;end; T.test;
<dminuoso>
Bish: There are instance variables inside the _CLASS_ object
karapetyan has quit [Remote host closed the connection]
xuyuheng has joined #ruby
<dminuoso>
Bish: and there are instance variables inside the "normal" object
<dminuoso>
Bish: instance variables by default are HIDDEN, that is a good thing.
<dminuoso>
You shouldn't get direct access to them.
<Bish>
simple use case = share data between 2 methods inside class << self
<elomatreb>
What are you trying to do, actually? Because @@ vars usually end up biting you down the line, even if you manage to use them "correctly"
<dminuoso>
Bish: attr_reader
<Bish>
so far i am only able to do it with class <<self
<dminuoso>
and then go self.class.foo
iMadper has quit [Remote host closed the connection]
<Bish>
i mean @@
<Bish>
dminuoso: guess that would be possible
<Bish>
but kinda equivalent
schneider has joined #ruby
<dminuoso>
Bish: @@ just leads to quirky and buggy code most of the time.
zautomata3 has joined #ruby
zautomata3 has quit [Client Quit]
<dminuoso>
And it exposes details into entire inheritance hierarchies
zautomata has joined #ruby
<dminuoso>
11:35 elomatreb | What are you trying to do, actually? Because @@ vars usually end up biting you down the line, even if you manage to use them "correctly"
<dminuoso>
?xy
<ruby[bot]>
it seems like you are asking for a specific solution to a problem, instead of asking about your problem. This often leads to bad solutions and increases frustration for you and those trying to help you. More: http://meta.stackexchange.com/a/66378
<Bish>
they never hurt me, but i try to listen to oyu
<dminuoso>
"Look, guns are not dangerous. I not shot myself"
<elomatreb>
Sharing data between two methods inside class << self: https://eval.in/986182 ?
<Bish>
i never shot myself*
<dminuoso>
You get the point.
<Bish>
it's just stupid that 3rd from of hurt is the same
RyanMcCoskrie has joined #ruby
zautomata2 has quit [Ping timeout: 265 seconds]
<dminuoso>
Bish: at any rate, "class methods" are no different from "instance methods"
<Bish>
elomatreb: yeah well :D i thought about this one too
<dminuoso>
Bish: they are all just regular methods.
<Bish>
dminuoso: yeah i get that
<dminuoso>
Bish: So how do you share data between "regular" instance methods?
<Bish>
guess the inheritance argument is valid, but i don't use that often
<dminuoso>
instance variables right?
<Bish>
dminuoso: usually, yes
<dminuoso>
Bish: Great. Since we have established that class methods are no different from "instance methods", it makes for consistent code.
<dminuoso>
Bish: If you think you want class variables to dripple down through inheritance, I can promise you: you dont.
<elomatreb>
Imagine how weird it was if changing an instance variable on some "regular" instance messed with other instances. That's essentially what @@vars do
<Bish>
well, all you say is right.. but i feel like @ inside class << self should be @@
ta_ has quit [Remote host closed the connection]
<dminuoso>
Im willing to say: The presence of class variables is almost always an indicator of a bug.
<Bish>
i won't argue that what you say is cleaner code
<Bish>
but this behaviour is still stupid
<dminuoso>
Just like `volatile` in C.
schneider has quit [Ping timeout: 240 seconds]
KeyJoo has quit [Quit: KeyJoo]
<dminuoso>
Bish: What behavior is stupid?
<dminuoso>
Bish: That objects dont expose their details?
<Bish>
that i can create a instance variable inside class << self, and not use it inside its methods
<Bish>
dminuoso: because i already took your advice of not doing it that way
<elomatreb>
Personal opinion: If you are doing this at all you should be careful, you're creating centralized, mutable state that can be hard to test/keep bug-free
<dminuoso>
Bish: but youc an use it inside methods.
<dminuoso>
Bish: You're in different universes.
<Bish>
but it's still stupid that it's not possible, what i wante dto try
<dminuoso>
You are trying to share between universes.
<dminuoso>
*that* is silly
<Bish>
dminuoso: so
<Bish>
begin @lol = 3;def careful_different_universe; p @lol; end;
<Bish>
sounds good to you?
<Bish>
while EVERYWHERE else in ruby this works?
<dminuoso>
What?
<Bish>
.. i just feel like the combiniation
<elomatreb>
It *only* works in the main/"eval" context
<Bish>
@lol = 3;def x;p @lol;end; should always work
<dminuoso>
Bish: read: @lol = 3 as:
<dminuoso>
self.instance_variable_set(:@lol, 3)
<dminuoso>
so the question you should ask yourself
<dminuoso>
"what is self in this context right now"
<dminuoso>
what is the `object` you are focussing
<Bish>
yes, and the context is the same, which i create the method in
<Bish>
and that method has no freaking access to the variable i just created in the same context
<Bish>
so that's exactly what i am mad about
ta_ has joined #ruby
<dminuoso>
no it is not the same.
<dminuoso>
class Foo; ... here self is the class object ...; end
<Bish>
in terms of code it is.. i understand where the problem is
cam27 has quit [Quit: cam27]
<elomatreb>
It's not, that's the essential difference. The only place where they are the same is in the case where self is "main", i.e. you're working on top-level outside of classes
<dminuoso>
class Foo; def m... here self is the instance object ... end; end
<dminuoso>
See the difference?
<Bish>
you cannot just change the behaviour of @ just because it's inside a class << self;
<dminuoso>
Bish: no not in terms of code.
<dminuoso>
Bish: you have the wrong idea about what `self` is in different places.
<elomatreb>
@ never changes behavior, that's the "beauty" of it
<Bish>
no.. i understand it very well now
<dminuoso>
Bish: apparently you dont.
<Bish>
doesn't change the fact i think it's stupid
<Bish>
i do, i just think it's stupid
schneider has joined #ruby
alfiemax has joined #ruby
<dminuoso>
Bish: if you understand it very well, you wouldn't have asked your question to begin wtih so..
<Bish>
i understand it now, i didn't in the beginning
<dminuoso>
Bish: But I do agree, that things like `self`, default assignee and other things are way too random
<dminuoso>
It's frequently hard to keep track of `what self is in the place you are looking at`
<Bish>
it's as stupid as having to add @ or @@ when accessing class/instance variables as symbol
<dminuoso>
Bish: forget about class variables.
<dminuoso>
they are an accident.
<tobiasvl>
never add @@
<Bish>
okay, then it's stupid to add @ when accessing instance variables as symbols
<Bish>
as stupid*
<Burgestrand>
Does @lol = 3; def x; p @lol; end ever work outside of main?
<dminuoso>
Bish: Well that I agree with. :-)
<elomatreb>
The argument here is that the symbol-based accessor functions are hax anyway
<dminuoso>
Bish: It's (ab)used in core to provide for hidden instance variables you cant possibly access.
<Bish>
Burgestrand: .. im doing that all the time inside classes? am i stupid?
zautomata1 has joined #ruby
<dminuoso>
Bish: so that ruby actually uses instance variables like `:foo` but they are completely inaccessible, because the frontend requires `:@...`
ta_ has quit [Remote host closed the connection]
<elomatreb>
Accessing an undefined instance variable returns nil, so you might just not notice it? Because it will most certainly not do what you expect in classes
<Burgestrand>
Bish to verify, you write stuff like this all the time: https://eval.in/986192
<Burgestrand>
Bish ?
<Bish>
>> class T;@lol = 3;def test; p @lol;end; p T.new.test
<ruby[bot]>
Bish: # => /tmp/execpad-4bb94c3fc112/source-4bb94c3fc112:7: syntax error, unexpected end-of-input, expecting ke ...check link for more (https://eval.in/986193)
<Bish>
>> class T;@lol = 3;def test; p @lol;end;end; p T.new.test
<dminuoso>
Bish: Like I said, Im sure you dont understand it yet.
zautomata has quit [Ping timeout: 256 seconds]
<Bish>
well.. i am sure im doing this alll the time
ta_ has joined #ruby
<dminuoso>
If you do then you have lots of bugs
<dminuoso>
11:48 elomatreb | Accessing an undefined instance variable returns nil, so you might just not notice it? Because it will most certainly not do what you expect in classes
<Bish>
am i not?
<Bish>
looks like i am not.
<Bish>
weird.
<Bish>
why did i ever think it's this way
<Burgestrand>
It's a common thing in e.g. java, php, python (?)
<Burgestrand>
Swift too
<dminuoso>
Bish: Because Ruby tries to act as if its some Javaism, while in truth it has a completely different object model
<Bish>
but i am doing ruby alooooot
<elomatreb>
I can see why people are confused/inconvenienced by this, e.g. having to initialize lots of stuff inside the constructor method does feel weird
<dminuoso>
elomatreb: Things get really subtle when you also talk about class_eval/instance_eval
<Burgestrand>
It's uncommon for sure
<Burgestrand>
However, if you frame it as "you can't assign instance variables on instances that don't exist" I do think it makes sense, it doesn't make it more intuitive though
<phaul>
Bish: I keep recommending this to everybody all the time, yu might have seen it. It's the best explanation of this Ive seen https://www.youtube.com/watch?v=X2sgQ38UDVY
<dminuoso>
Bish: Ultimately the main problem is that Ruby has no mechanism to filter out silly programs.
<Burgestrand>
I'm not sure any language does…
<dminuoso>
Burgestrand: Lots do.
<dminuoso>
Burgestrand: The mechanism is called: type system.
<Burgestrand>
dminuoso yeah, no, not buying that
<Bish>
dminuoso: it's weird, i do so much shit that people tell me not to do
<Bish>
and it almost never hurts
<Bish>
i have some really hardcore ugly @@ shit inside my codebase
<Bish>
and it works like a charm
<dminuoso>
"works like charm"
<dminuoso>
Bish: Its not about whether it works, its about what implications it has for design
<dminuoso>
Potential pitfalls
<dminuoso>
And whether it leads to wrong abstractions
<elomatreb>
Weird stuff gets exponentially more problematic as you increase the number of developers on something
<Bish>
yeah guess that's true
<dminuoso>
Bish: And if you practice this on your own, you will develop habits that are really hard to kick
<dminuoso>
after a while you convince yourself that "this is right because my program works"
<dminuoso>
And that's how bad developers develop.
<Burgestrand>
dminuoso and to make it clear, I do enjoy languages with different type systems from ruby (e.g. haskell, swift, c) partly _because_ of their type system, but they do have their own challenges and I still enjoy my ruby
<elomatreb>
Imagine e.g. a new dev coming along and extending your class to do something new, and just because they didn't read or notice that your class uses @@s you now have weird shared state bugs
erlend has quit [Ping timeout: 264 seconds]
<dminuoso>
Burgestrand: not sure why you are "not buying that"
<Burgestrand>
dminuoso I would not go as far as saying they filter out silly programs more than ruby, python, php, or blub
<dminuoso>
Burgestrand: The entire purpose of a type system is to filter out bad/incorrect/wrong programs while filtering out as few good programs as possible.
<Burgestrand>
elomatreb ;)
<dminuoso>
Burgestrand: Good type systems let you express domain specific things even.
<dminuoso>
Burgestrand: If it doesn't type check, that's just an expression for: "Your program does not make sense here. This is a bug"
ramfjord has joined #ruby
erlend has joined #ruby
<Burgestrand>
dminuoso it certainly sounds like you're arguing for that a robust type system is objectively better
zautomata1 has joined #ruby
<dminuoso>
Burgestrand: Im studying type theory currently, so Im beginning to understand a lot of the motivation and techniques. There's basically very few reasons to _not_ have a type system.
<elomatreb>
Better in terms of safety/program correctness isn't hard to argue, it's a balancing act with "productivity"/easy of use
<dminuoso>
elomatreb: The second you have type inference the "productivity" argument falls apart.
schneider has joined #ruby
<dminuoso>
You get types for free.
<Burgestrand>
dminuoso except not all type systems are not sound, i.e. they can't be proven correct even if types line up
<phaul>
If type systems are there to ensure propgram correctness, than a test system like RSpec is far more expressive than that
Xiti` has joined #ruby
<dminuoso>
phaul: no its not.
karapetyan has joined #ruby
<elomatreb>
dminuoso: Productivity is a difficult term anyway, I was thinking of things like Rust where it takes a long while to get started for most precisely because of the type system
<dminuoso>
phaul: It's the other way around really. RSpec has to check whether under all possible conditions the right types flow through the program. It cant simulate any state and input.
ramfjord has quit [Ping timeout: 260 seconds]
<dminuoso>
phaul: Let me argue why.
<dminuoso>
phaul: Did you ever have the situation where you made some error (maybe a typo, maybe just a flaw in your head), just to see some NoMethodError because the thing you are holding in your hands is something different?
<dminuoso>
Maybe it was some Symbol/String confusion. Or maybe instead of a `Client` object you actually get back a `Client::Proxy`, or actually an Array
xuyuheng has quit [Quit: Quit: My MacBook Pro has gone to sleep. ZZZzzz?]
inerthia_ has joined #ruby
<dminuoso>
phaul: Why did this happen? Because you mentally ran the types and you made a mistake. Now imagine how frequently happens.
<dminuoso>
Why should you suddenly be rigorously correct when writing specs?
<phaul>
sure. I am not saying that type systems are useless, or they cannot protect against certain issues
<dminuoso>
You're writing the specs under the already existing assumption that your code is right. You dont know *where* its wrong.
<dminuoso>
If you did, you would be fixing the bug instead.
zautomata2 has joined #ruby
inerthia_ has quit [Client Quit]
Xiti has quit [Ping timeout: 264 seconds]
zautomata1 has quit [Ping timeout: 268 seconds]
inerthia_ has joined #ruby
<dminuoso>
phaul: It's not about "my program is correct", but its rather about "my program is definitely not obviously incorrect"
<phaul>
But you can express very comlex expectations with RSpec, the expectation is basically just ruby. It can be hard to express the same in a type signature
fullstack has quit [Ping timeout: 256 seconds]
<Burgestrand>
… but that's not true, just because the type system lines up there's no guarantee that your program isn't obviously incorrect
<dminuoso>
phaul: Sure. Im not saying that any invariant goes into a type.
karapetyan has quit [Ping timeout: 260 seconds]
<elomatreb>
And not every type problem always implies an actual problem
<dminuoso>
Burgestrand: Well it doesnt replace the test. But a type system proves program wide that NoMethodErrors cant happen.
<dminuoso>
Burgestrand: It doesnt just test based on some random input, it *proves* it.
schneider has quit [Ping timeout: 264 seconds]
<dminuoso>
elomatreb: Sure. That's basically the main thing to consider.
<dminuoso>
elomatreb: type systems do filter out some good programs, but usually they are few.
<elomatreb>
Yeah, that's where the tradeoffs and ergonomics come in
<Burgestrand>
dminuoso I agree with what you're saying, but I don't understand the point you're trying to make
<dminuoso>
elomatreb: An expressive type system will let you work around many of such cases, say some form of ad-hoc polymorphism will take care of situations where you need an `int` to fit into a `long`
<dminuoso>
(because if you want ergonomics, then you want type inference, and subtyping basically breaks type inference left and right)
<elomatreb>
Another good example IMO is .unwrap() in Rust, while the type system says "this value may be absent" I can override it because I know it to be there
<dminuoso>
elomatreb: Yeah. Most languages have some sort of backdoor for type systems.
schneider has joined #ruby
<phaul>
my biggest argument for a type system like haskell's is that it clearly communicates the intention of the function as long as it's just plain types. but when you push more and more complex stuff in the type systems, to "catch more" bugs, that's when it starts becoming painful. dependent types. thank you but not thank you :)
<phaul>
*no*^
* elomatreb
mumbles something about Gödel
<dminuoso>
elomatreb: Though it's questionable whether that's the right approach though.
<dminuoso>
I mean in some cases you have a way of proving totality for certain cases, then some .unrwap is fine.
<dminuoso>
In Ruby that amounts to `using . instead of &.`
<dminuoso>
But we rarely prove totality. We just assume we never get a nil back everywhere
<dminuoso>
Until we do.
j0bk has joined #ruby
<elomatreb>
With the difference being that &. does something silently weird, whereas a violated .unwrap()-expectation will cause a runtime error
<dminuoso>
elomatreb: actually they are the same kind of.
<dminuoso>
elomatreb: lets assume for a second that you always use `&.`. This means if any method returns a `nil`, it shortcircuits computation.
<elomatreb>
Oh, I thought about the wrong way around. I get what you mean now
dr3w_ has joined #ruby
<dminuoso>
elomatreb: pattern matching is more elegant than .unwrap though
<elomatreb>
It's the same thing though in my example, just with the None branch being a runtime error
schneider has quit [Ping timeout: 256 seconds]
<dminuoso>
oh yeah
dr3w_ has quit [Client Quit]
<dminuoso>
elomatreb: I mean ultimately Ruby users make type assumptions everywhere. If you type `.length` you are expressing an implicit assumption that you are holding some `Array` in your hand.
<elomatreb>
Anything that has #length, yeah, the expectation that it's an Array is implicit
<elomatreb>
Which is probably more of a problem than expecting something to have a method I think? Because it doesn't necessarily cause an immediate error, but does something silently different
<dminuoso>
Sure. You could say .count more generally and mean Enumerable
<dminuoso>
elomatreb: I mean we have to assume that the implementation of whatever interface you are using is lawful/correct right?
dr3w_ has joined #ruby
schneider has joined #ruby
<elomatreb>
Mh, this discussion is becoming a bit pointless in the Ruby context, because somehow Ruby programs manage to crash rarely compared to how many assumptions are being made
<dminuoso>
elomatreb: So you never run your code in between saving to see whether the code you have written is correct?
sylario has joined #ruby
<dminuoso>
You must be one mighty good ruby developer to always write correct Ruby on the first save.
<elomatreb>
I do, but I also spend a lot of time fixing my code to appease the Rust type checker
<dminuoso>
elomatreb: So if you make that many incorrect type assumptions in Rust, why would you be any better in Ruby?
<dminuoso>
My argument is: Your rust experience should demonstrate how frequently wrong our assumptions are.
<elomatreb>
I agree completely, it's just that this leads nowhere (unless there are plans to introduce a type system to Ruby?)
<dminuoso>
There are.
<dminuoso>
=)
<dminuoso>
Matz did some talks recently about it
<elomatreb>
OK, I admit I don't really follow Ruby development like that, a little presumptive to say something like that, sorry
<dminuoso>
elomatreb: It's a really lackluster type system though. Basically the same problems that bust optimizations also bust a type system. Ruby is simply too dynaimc.
schneider has quit [Ping timeout: 260 seconds]
<dminuoso>
(I mean how do you statically determine whether some thing has a method with a correct signature when you can simply .define_method it away dynaically)
<dminuoso>
Or you generate an ISeq stream to do the same, and compile/run it.
<elomatreb>
Or randomly add/remove methods, which is my favorite example for this, yeah
<dminuoso>
I think Crystal manages to do all these things by simply removing the dynamic nature of things.
ur5us has joined #ruby
schneider has joined #ruby
<Bish>
yeah i was hyped about crystal, too
<Bish>
until i realized it removes everything that makes ruby cool
rabajaj has joined #ruby
schneider has quit [Ping timeout: 260 seconds]
indiche has joined #ruby
blackmesa has joined #ruby
Burgestrand has quit [Quit: Closing time!]
stormpack has joined #ruby
schneider has joined #ruby
fullstack has joined #ruby
rahul_bajaj has joined #ruby
blackmesa has quit [Ping timeout: 246 seconds]
rabajaj has quit [Ping timeout: 255 seconds]
blackchalk has joined #ruby
<Bish>
i once heard doing immutable objects makes better cached code, how does that work
<Bish>
well.. macros is not metaprogramming.. it alwayshas more limits
<Bish>
than being able to walk over all classes of a module and patch the methods
<dminuoso>
Bish: If programs that transform programs is not metaprogramming, I dont know what is.
<dminuoso>
"patch the methods"
<Bish>
yes.
<dminuoso>
Bish: Why would you want to do that?
<dminuoso>
Bish: Imagine this:
<dminuoso>
You write a class:
<Bish>
i enjoy things like.. that you can write fibonacci naive and cache it with extern code
<dminuoso>
class Foo; def bar; important_code_goes_here; end; end
<Bish>
(not that i would recommend) but i did something like that
<dminuoso>
and some other file does
<dminuoso>
require 'money'
<dminuoso>
and the `money` gem happens to *PATCH* the class Foo.
<dminuoso>
Would you be happy?
<Bish>
what i once had was.. i wrote code.. that did a lot of database queries.. and it was stupid and big
<Bish>
but it was super slow.. so i patched it from outside making every method 'memorized'
schneider has quit [Ping timeout: 268 seconds]
<dminuoso>
Bish: Why not *fork* the thing and fix it?
<Bish>
i tried, i couldn't because that would've been alot of work
<dminuoso>
Bish: You suddenly end up with some thing that LOOKS as if its the original, but in fact is not.
<Bish>
yes :) but it made me happy and didn't cost time
<dminuoso>
Which is horrible for anyone that doesnt know all yuor magic hooks and monkepatches
<Bish>
i don't say you should do that
<Bish>
i say it's cool it's possible
<dminuoso>
Bish: Also there are simple idioms for memorization.
<dminuoso>
*memoization even!
<dminuoso>
Bish: monkey patching is an anti pattern.
<Bish>
so is IPC over database, and i luv it
<Bish>
fact is no matter how you do it, someone will call it an anti pattern
<dminuoso>
Bish: The problem with monkey patching is that its invisible and changes expectation
<dminuoso>
you have to understand *the entire* order in whcih your project will be eval'ed to understand how the software behaves
<Bish>
well, why use ruby then, that's all ruby has?
<dminuoso>
consider that a good thing? I dont.
<Bish>
i had the same discussion with a gem-maintainer
schneider has joined #ruby
<Bish>
he changed all objects to be non-mutable from one version to the other
<Bish>
and i was like ":( i use that stuff alot"
<Bish>
and hes like " mutable objects are dangerous and performance sucks"
<dminuoso>
Bish: Imagine you're an ActiveRecord expert.
<dminuoso>
You hop into a rails project.
<dminuoso>
See a class that goes:
<dminuoso>
class User < ActiveRecord::Base; end
<dminuoso>
Would it be safe to assume that all your AR knowledge transfers over?
<dminuoso>
That `User.find(1)` will do the expected thing.
<dminuoso>
If any user at any time can monkey patch any method, it means if I show you this line of code:
<dminuoso>
[1,2,3].last
<dminuoso>
What is the result?
<dminuoso>
The answer is: Well that depends on the code that was executed before.. maybe this will print "7"
<dminuoso>
Maybe it will delete a file on the file system
<Bish>
i know what can go wrong.. but i don't get why you would use ruby otherwise
<Bish>
that was my argument there too
<Bish>
he was like "mutable objects are a gun lying around"
<Bish>
well, it's not lying.. but laying? i don't know
<dminuoso>
Ultimately mutable objects are fine as opt-in.
<dminuoso>
If you need mutability as an optimization, fine.
RougeR has joined #ruby
RougeR has quit [Changing host]
RougeR has joined #ruby
<dminuoso>
Bish: If you dont know whether ActiveRecord will modify the arguments you pass, then you are basically forced to deep_dup an argument.
<dminuoso>
If you want your assumption "my object is the same after the call" to hold.
<dminuoso>
Or you have to check the *entire* call tree and trace where that object and its parts get used.
<dminuoso>
And then you have to check the entire project, and *the entire source code of all transient dependencies* to know whether ActiveRecord was monkey patched
<dminuoso>
(Or any other code that may have somehow access to that)
ur5us has quit [Remote host closed the connection]
schneider has quit [Ping timeout: 265 seconds]
<dminuoso>
Dynamic code is freaking hard to reason about.
<Bish>
i know all that
<dminuoso>
Code that is freaking hard to reason about is likely buggy.
<Bish>
that's why i chill in haskell
<dminuoso>
Which is why nobody really uses dynamic features in Ruby except for certain metaprogramming techniques
<Bish>
and i agree.. you don't have to tell me that stuf
<dminuoso>
But thats mostly because we dont have AST-manipulation macros
<Bish>
dminuoso: but i don.t get the choice for ruby then
<dminuoso>
Bish: =)
<tbuehlmann>
on the upside, it doesn't have to be like that
\void has quit [Quit: So long, and thanks for all the fish.]
<Bish>
dminuoso: do stuff i put into Queues get dup-ed?
<Bish>
guess not, right?
apparition has joined #ruby
<dminuoso>
Bish: From my PoV the fact that you have to ask the question shows the problem.
<Bish>
well, no.. i am asking without having problems, doesn't mean i never have them
zautomata1 has joined #ruby
\void has joined #ruby
<Bish>
i am like 95% sure that it doesn't
zautomata has quit [Ping timeout: 265 seconds]
<dminuoso>
Bish: check out immutable-ruby
<dminuoso>
Bish: that thing gives you guarantees that are nice to work with
schneider has joined #ruby
ldnunes has joined #ruby
Burgestrand has joined #ruby
ta_ has quit [Remote host closed the connection]
ta_ has joined #ruby
vondruch has quit [Quit: vondruch]
amar has quit [Remote host closed the connection]
vondruch has joined #ruby
amar has joined #ruby
ta_ has quit [Ping timeout: 240 seconds]
jeffreylevesque has quit [Ping timeout: 260 seconds]
tcopeland has joined #ruby
ramfjord has joined #ruby
ramfjord has quit [Ping timeout: 260 seconds]
Guest2486 has quit [Quit: WeeChat 1.4]
<dminuoso>
The main reason I use Ruby is because we have Ruby projects in development. Newer tools are written in Haskell at the moment.
<dminuoso>
We have failed to identify any advantages of Ruby specifically compared to other languages for basically any task.
<dminuoso>
Apart from making it really easy to shoot yourself and others in the foot, head and hands.
vondruch has quit [Quit: vondruch]
vondruch has joined #ruby
duderonomy has joined #ruby
yohji has quit [Ping timeout: 256 seconds]
erlend has quit [Ping timeout: 276 seconds]
synthroid has joined #ruby
erlend has joined #ruby
adbjesus has joined #ruby
John_Ivan has joined #ruby
John_Ivan has joined #ruby
John_Ivan has quit [Changing host]
inerthia has quit [Quit: Byez]
adbjesus has quit [Client Quit]
adbjesus has joined #ruby
workmad3 has quit [Ping timeout: 240 seconds]
adbjesus has quit [Client Quit]
adbjesus has joined #ruby
yohji has joined #ruby
Burgestrand has quit [Quit: Closing time!]
Mortomes|Work has quit [Ping timeout: 260 seconds]
shinnya has joined #ruby
mostly-harmless has quit [Ping timeout: 256 seconds]
mostly-harmless has joined #ruby
pd2000 has quit [Read error: Connection reset by peer]
dr3w_ has joined #ruby
alfiemax has quit [Remote host closed the connection]
drale2k_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<veloutin>
dminuoso: there are a few positive points... it makes you appreciate the other languages you use more, and you feel rewarded when you figure out where a certain behavior was added inside all the dependencies.
indiche has quit [Ping timeout: 256 seconds]
donofrio has joined #ruby
psychicist__ has quit [Ping timeout: 264 seconds]
bmurt has joined #ruby
indiche has joined #ruby
barq has joined #ruby
adbjesus has quit [Quit: adbjesus]
alfiemax has joined #ruby
adbjesus has joined #ruby
<barq>
How can I install with gem behind a proxy? The docs says -p or --http-proxy but I gte no match for argument when I try gem -p 127.0.0.1 install
NL3limin4t0r has joined #ruby
alfiemax has quit [Ping timeout: 245 seconds]
<dminuoso>
veloutin: Corn mazes are good labyrinths too.
<dminuoso>
That doesn't make corn mazes a good tool for software development though.
<dminuoso>
Even though they are fun.
<dminuoso>
I'd rather spend my time being productive than debugging.
netherwolfe has joined #ruby
Psybur has joined #ruby
Burgestrand has joined #ruby
<veloutin>
it feels more and more like "There's more than one bad way to do it"
Strepsils has quit [Read error: Connection reset by peer]
chouhoul_ has joined #ruby
RougeR has quit [Ping timeout: 245 seconds]
memo1 has joined #ruby
netherwolfe has quit [Ping timeout: 240 seconds]
ramfjord has quit [Ping timeout: 264 seconds]
<memo1>
hi friends. Im learing Ruby, and im excuting bash command from ruby with open3. If i want to execute 2 or more commands, i have to: Open3.popen3(cmd1) do...Open3.popen3(com2)...etc?
chouhoulis has quit [Ping timeout: 255 seconds]
<Phrogz>
As promised on Friday, I made a gem of my little safe templating and evaluation library: https://github.com/Phrogz/Flooph
duderonomy has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
blackmesa has joined #ruby
<Bish>
memo1: using open3 to solve a problem should be the last straw if you ask me, but i don't want to be "that irc guy"
<Bish>
but why do you need open3?
<Phrogz>
memo1: Are you using open3 because you need to capture stderr, or because that's all you knew how to do.
<Phrogz>
Yeah, what Bish said :)
<Phrogz>
If you don't need to capture stderr, I'd just use output = `cmd1; cmd2; cmd3` (assuming Linux)
<Phrogz>
If you don't need to capture stderr, I'd just use output = `cmd1; cmd2; cmd3` (assuming Linux/OS X)
<Phrogz>
(Oops, too much Slack up-arrow editing. Sorry for spam.)
alfiemax_ has quit [Remote host closed the connection]
orbyt_ has joined #ruby
alfiemax has joined #ruby
ellcs has quit [Remote host closed the connection]
rfoust has joined #ruby
Strepsils has joined #ruby
shakes has quit [Quit: Leaving]
orbyt_ has quit [Ping timeout: 260 seconds]
<memo1>
Phrogz: Bish im using it because i need to use bash commands. I need to execute ffmepeg commads. I want to execute 3 times, because i have 3 cameras.
erlend has quit [Ping timeout: 256 seconds]
erlend has joined #ruby
<Bish>
that's like the only valid use case there is :D ffmpeg
<Phrogz>
Bish: Yes, you can, because Hash#== is special-cased from Object#==
Burgestrand has quit [Quit: Closing time!]
netherwolfe has joined #ruby
aupadhye|brb has quit [Ping timeout: 240 seconds]
<Bish>
Phrogz: i figured
<Bish>
Phrogz: but is it fast? like
<Bish>
if i have
<Bish>
[1,2,3] = {..huge.ass object}
<Bish>
will it go all through huge ass object
drale2k_ has joined #ruby
indiche has quit [Ping timeout: 240 seconds]
louvre06_ has joined #ruby
k0mpa has joined #ruby
skweek has joined #ruby
memo1 has joined #ruby
ramfjord has joined #ruby
louvre06 has quit [Ping timeout: 260 seconds]
ltt has joined #ruby
amatas has joined #ruby
amatas has quit [Client Quit]
amatas has joined #ruby
yeticry has quit [Read error: Connection reset by peer]
ramfjord has quit [Ping timeout: 256 seconds]
yeticry has joined #ruby
ramfjord has joined #ruby
blackmesa has quit [Ping timeout: 276 seconds]
<Phrogz>
Bish: I don't know. My knee-jerk response is "test it and see". My dismissive gut reaction is "it's fast enough you don't need to care". But I truly don't know.
lelliott has joined #ruby
spiette has joined #ruby
rfoust has quit [Ping timeout: 276 seconds]
schneider has quit [Ping timeout: 240 seconds]
alfiemax has quit [Remote host closed the connection]
apeiros has joined #ruby
<Phrogz>
In general, Ruby has been around long enough, and MRI has been be rewritten and optimized enough, that I expect intelligent decisions have been made at the core, especially involving such fundamental data types.
pd2000 has joined #ruby
ramfjord has quit [Ping timeout: 260 seconds]
alfiemax has joined #ruby
<apeiros>
Bish: since [] is an array and {} is a hash, that'll instantly return false
<apeiros>
if you actually do have to huge hashes, then yes, if they're equal, all objects within it will be compared
Cavallari has quit [Quit: Cavallari]
<apeiros>
unless it's the *same* hash, as in a.equal?(b), that test is done first and it's assumed that a.equal?(b) implies a == b
<apeiros>
(and honestly, if you manage to fuck that up, you earn it if == returns wrong results)
<apeiros>
*deserve
* phaul
blushes :)
<apeiros>
phaul: you managed that? :D
<phaul>
I was hacking tho, well aware of what I was doing. I need to cheat the system in a challange
<apeiros>
:-p ok
Cavallari has joined #ruby
<phaul>
that's where I found that even the stdlib rdoc is not always aware of this
clemens3_ has quit [Remote host closed the connection]
fiachetti has joined #ruby
dr3w_ has quit [Read error: Connection reset by peer]
sanscoeur has quit [Remote host closed the connection]
cschneid_ has joined #ruby
synthroid has quit [Remote host closed the connection]
<Phrogz>
:)
dr3w_ has joined #ruby
<phaul>
or more precisely there is an implicit assumption that you don't hack ==, or statements in the documentation might not hold
alfiemax has quit [Remote host closed the connection]
<apeiros>
hm, I actually found a case where the assumption breaks
<apeiros>
or rather, remembered
memo1 has quit [Ping timeout: 265 seconds]
<apeiros>
>> a = [Float::NAN]; a == a # note: `Float::NAN == Float::NAN` => false
<quuxman>
In this case I don't want the double to resemble the original object at all, just have one method that when called, ends the test succesfully, and if it wasn't called by the end of the test, it fails
<quuxman>
So if the method is defined on a global object that's called by the code I'm testing, I could use something like: Foo::Bar.baz = double; expect(Foo::Bar.baz).to receive(:do_stuff) #?
t0rchh has quit [Ping timeout: 240 seconds]
<phaul>
don't do that use let construct
<quuxman>
what would that look like?
<phaul>
let (:something) { double('blah') } ; it 'receives stuff' { expect something.to receive(:stuff) }
mikecmpbll has joined #ruby
<quuxman>
but then how would the code being tested actually call the double? It uses the gobal reference
<phaul>
ah, dependency injection :)
<phaul>
if it's a global refrence then you can point that reference to the double as you did, but then you have to make sure you reset it otherwise you have leaky tests
<phaul>
you could do something like that with the before and after hooks
karapetyan has joined #ruby
<quuxman>
ah ok, thanks
k0mpa has quit [Ping timeout: 268 seconds]
<sparr>
apeiros: thanks
duderonomy has joined #ruby
pd2000 has quit [Read error: Connection reset by peer]
amar has joined #ruby
<sparr>
other than an explicit call to somestring.to_sym, what code might trigger an implicit string.to_sym?
Yxhuvud has joined #ruby
pd2000 has joined #ruby
duderonomy has quit [Client Quit]
rivalomega has quit [Remote host closed the connection]
drale2k_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
sauvin has quit [Read error: Connection reset by peer]
lelliott has quit [Remote host closed the connection]
Eiam has joined #ruby
<Eiam>
when doing a .reduce is there some way to get the original object being passed to reduce? I thought something like method(__method__).parameters but, no dice
<Eiam>
I want to know how long the original array is
alfiemax has quit [Remote host closed the connection]
<Eiam>
and I don't want to store it in a value outside of the block
workmad3 has quit [Ping timeout: 255 seconds]
<phaul>
you can hack it in the accumulator I guess, but it's ugly. why not store it in a variable?
<baweaver>
Eiam: what exactly are you trying to do?
<baweaver>
Because this sounds like a very specific solution you're seeking where a more general solution could be better
<Eiam>
baweaver: I've got an array with either a string with content or an empty string and I want to merge them all together with /
<Eiam>
but I don't want a trailing / or empty //
<Eiam>
oh
<baweaver>
join
<Eiam>
join leaves a /
alfiemax has joined #ruby
<baweaver>
join and sub/strip
<Eiam>
["a","b",""].join("/") ==> "a/b/"
<Eiam>
middle missing gives "a//c"
<baweaver>
>> ["a","b",""].join('/').rstrip('/')
<ruby[bot]>
baweaver: # => wrong number of arguments (given 1, expected 0) (ArgumentError) ...check link for more (https://eval.in/986596)
<baweaver>
Ah
<Eiam>
guess i can remove the mfirst
<phaul>
join in the reduce, but don't join if empty
Azure has quit [Read error: Connection reset by peer]
Azure has joined #ruby
chouhoulis has joined #ruby
memo1 has joined #ruby
Burgestrand has quit [Quit: Closing time!]
<quuxman>
phaul: I don't see anything about that in the doc you linked. There's just before(:all) and before(:each). I have many context blocks in a describe block, and I want to set then unset a global before and after just one of the context blocks
chouhoul_ has quit [Ping timeout: 240 seconds]
<phaul>
have you seen my gist why that upsets RSpec soubles?
<phaul>
*doubles ^
mtkd has quit []
tcopeland has quit [Quit: tcopeland]
<quuxman>
yeah. I guess I could actually do before and after :all because this particular global isn't used anywhere else in the file. But I don't know if that would leak outside this particular test file
<quuxman>
I imagine it would when running the full test sweet
<quuxman>
*suite
<phaul>
quuxman: my point with that gist is that if you look at what happened in the second example that is identical to the first, it failed.
<phaul>
I tried to demonstrate what not to do, and why
<quuxman>
ah ok, so I should just forget about before and after, and do it for every test case
<quuxman>
there are only 2 anyway
<phaul>
there is before(:each), after(:each) that you should use for this.
<quuxman>
but I don't want to do that, because there a _lot_ of tests in this describe block
Creatornator has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
chouhoulis has quit [Remote host closed the connection]
chouhoulis has joined #ruby
<phaul>
But setting up a mock is really cheap. and you don't really have a choice, you can reuse a mock
<phaul>
*can't
<phaul>
sigh, my typing is really bad sorry
<phaul>
you cannot reuse the mock across examples
<quuxman>
only 2 tests will use the mock, so before(:each) will be confusing because it won't be clear which test it's for. Guess adding a comment isn't the end of the world or anything
Burgestrand has joined #ruby
<phaul>
is there a sensible context block you can use for those 2 tests?
<phaul>
put them in a context and do the before(:each) inside that context
<quuxman>
aaah you can do that. Cool
<phaul>
oh, yeah you can arbitrarily nest describes, and contexts
<quuxman>
That's pretty nice how you can just add blocks that are basically comments (I'm pretty much completely new to Ruby)
<quuxman>
but are also blocks and can contain things like before and after
<phaul>
so when you are inside a context or a describe then you can define befores, afters, and it examples. You don't have access to expects and doubles. Inside the before and after, and inside the it example blocks you can use the doubles, and the expects. It pretty much holds your and and doesn't let you misuse it.
<phaul>
actually expect are only in it examples of course
<phaul>
*holds your hand^
jeffreylevesque has joined #ruby
Creatornator has joined #ruby
cr3 has quit [Quit: leaving]
Cork has quit [Quit: .]
mooe has joined #ruby
n0m4d1c has joined #ruby
ElFerna has joined #ruby
Cork has joined #ruby
orbyt_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
John_Ivan has quit [Read error: Connection reset by peer]
guacamole has joined #ruby
guacamole has quit [Changing host]
guacamole has joined #ruby
plexigras has quit [Quit: WeeChat 2.0.1]
Creatornator has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
\void has quit [Quit: So long, and thanks for all the fish.]
phaul has quit [Ping timeout: 256 seconds]
orbyt_ has joined #ruby
jamesaxl has quit [Quit: WeeChat 2.1]
zapata_ is now known as zapata
rivalomega has quit [Remote host closed the connection]
workmad3 has joined #ruby
rivalomega has joined #ruby
Creatornator has joined #ruby
workmad3 has quit [Ping timeout: 256 seconds]
rivalomega has quit [Remote host closed the connection]
rivalomega has joined #ruby
ur5us has quit [Read error: No route to host]
ur5us has joined #ruby
adjustingmaitai has quit [Read error: Connection reset by peer]
venmx has joined #ruby
tcopeland has joined #ruby
cadillac_ has quit [Ping timeout: 260 seconds]
cadillac_ has joined #ruby
ElFerna has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ElFerna has joined #ruby
ElFerna has quit [Client Quit]
troulouliou_div2 has quit [Remote host closed the connection]
mikecmpbll has joined #ruby
cschneid_ has quit [Remote host closed the connection]