impermanence

Activity Graph

Page 1 of 5 | Next »

2018-11-07

[02:42:09] impermanence: Remote host closed the connection

2018-11-06

[17:29:57] impermanence: has joined #ruby

2018-11-02

[16:26:54] impermanence: has joined #ruby
[23:24:37] impermanence: Ping timeout: 244 seconds

2018-11-01

[01:10:58] impermanence: Remote host closed the connection

2018-10-31

[00:15:00] impermanence: has joined #ruby
[07:14:07] impermanence: Remote host closed the connection
[16:21:19] impermanence: has joined #ruby
[16:59:02] impermanence: Remote host closed the connection
[19:24:29] impermanence: has joined #ruby

2018-10-30

[01:16:44] impermanence: Remote host closed the connection
[16:19:18] impermanence: has joined #ruby
[20:47:55] impermanence: Remote host closed the connection

2018-10-29

[15:51:53] impermanence: has joined #ruby

2018-10-09

[18:23:45] impermanence: has joined #ruby
[23:25:34] impermanence: Remote host closed the connection

2018-10-08

[21:30:23] impermanence: has joined #ruby
[23:34:38] impermanence: Ping timeout: 245 seconds

2018-09-18

[17:28:25] impermanence: has joined #ruby
[17:29:05] impermanence: we're having a stupid debate on my team. which is better or more current: rvm or rbenv. I say rvm, the other guy says rbenv. I know it's stupid, but is there a consensus?
[17:36:22] impermanence: Remote host closed the connection
[17:42:57] impermanence: has joined #ruby
[17:43:14] impermanence: has left #ruby: ()
[17:43:30] impermanence: has joined #ruby
[22:04:43] impermanence: Ping timeout: 244 seconds

2018-09-13

[12:36:47] impermanence: has joined #ruby
[12:41:56] impermanence: Ping timeout: 272 seconds

2018-09-12

[15:47:08] impermanence: has joined #ruby
[16:44:03] impermanence: Remote host closed the connection
[17:20:15] impermanence: has joined #ruby
[18:47:07] impermanence: Remote host closed the connection

2018-09-10

[18:07:43] impermanence: has joined #ruby
[19:50:41] impermanence: Remote host closed the connection
[19:50:59] impermanence: has joined #ruby
[23:27:05] impermanence: Remote host closed the connection

2018-08-20

[19:30:58] impermanence: has joined #ruby
[21:45:27] impermanence: Remote host closed the connection

2018-08-19

[18:16:27] impermanence: has joined #ruby
[23:10:44] impermanence: Remote host closed the connection

2018-08-18

[16:15:53] impermanence: Remote host closed the connection

2018-08-17

[15:26:42] impermanence: Remote host closed the connection
[16:53:52] impermanence: has joined #ruby

2018-08-16

[16:09:35] impermanence: has joined #ruby
[17:53:51] impermanence: Remote host closed the connection
[19:32:19] impermanence: has joined #ruby

2018-08-12

[00:15:39] impermanence: Remote host closed the connection

2018-08-11

[19:12:05] impermanence: has joined #ruby

2018-08-10

[15:57:30] impermanence: has joined #ruby
[17:47:05] impermanence: Ping timeout: 240 seconds

2018-01-24

[00:53:36] impermanence: has joined #ruby
[01:52:26] impermanence: Remote host closed the connection
[15:22:28] impermanence: has joined #ruby
[15:23:03] impermanence: How can I grab a .deb or .dpkg or whatever is used in debian, not install it, but still be able to compare it to another installation?
[15:23:35] impermanence: of the same package?
[15:27:36] impermanence: apeiros: bah. guess my client defaults to Ruby. apologies.
[15:34:23] impermanence: Ping timeout: 248 seconds
[16:46:08] impermanence: has joined #ruby
[17:09:00] impermanence: Ping timeout: 268 seconds

2017-12-09

[18:47:21] impermanence: has joined #ruby
[18:47:58] impermanence: is there a typical way to dir structure src and tests? src/ test/ or...?
[19:03:32] impermanence: dminuoso: true dat. I mean, like, java has some norms'n'forms so...sjust curious.
[19:05:00] impermanence: dminuoso: makes sense to me :)
[19:06:59] impermanence: dminuoso: ah, I see.
[19:08:57] impermanence: as a newbie I like, tooootally just ask on irc ;)
[19:10:51] impermanence: dminuoso: a process monitor that reads from /proc/ and writes to ncurses or something similar.
[19:12:06] impermanence: yeah and this morning I was all like...wait...maybe I just have a test dir, lib dir, bin dir, etc...but didn't know if there were forms
[19:12:23] impermanence: *should have a test dir, etc.
[19:13:22] impermanence: So far I copied from the link that leitz posted: lib/ bin/ test/
[19:14:28] impermanence: dminuoso: hm. I was putting my minitests in there...I'm...new to ruby testing, lol
[19:15:14] impermanence: oh okay, right on
[19:17:45] impermanence: dminuoso: I'm new to minitest too but spec functionality makes up about a third of its purpose
[19:18:08] impermanence: minitest: unit, spec, mock, benchmark
[19:21:02] impermanence: leitz: I'm a total ruby newb, but I find that when I write actual applications it makes me better, thas all. I am beginning to know *nix fairly well and I was recently looking at process mon tools so I figured I'd just write my own. nuffin special.
[19:22:14] impermanence: leitz: not really
[19:22:39] impermanence: certainly nothing with an SE competency
[19:24:56] impermanence: leitz: that's the plan
[19:35:19] impermanence: Remote host closed the connection

2017-12-02

[18:49:56] impermanence: has joined #ruby
[19:12:18] impermanence: Ping timeout: 260 seconds

2017-11-22

[20:38:34] impermanence: has joined #ruby
[21:00:35] impermanence: Remote host closed the connection

2017-11-21

[16:19:54] impermanence: has joined #ruby
[16:20:11] impermanence: I have an issue on one of my agents that is apparently being caused by my master caching "stuff"
[16:20:22] impermanence: where are these caches typically and can I just delete them?
[16:20:28] impermanence: If not how do I restart a master?
[18:30:57] impermanence: Ping timeout: 248 seconds

2017-11-18

[00:38:48] impermanence: Remote host closed the connection

2017-11-17

[23:05:56] impermanence: has joined #ruby
[23:06:29] impermanence: Does anyone have experience using elasticsearch-py?

2017-11-15

[18:41:09] impermanence: has joined #ruby
[23:42:25] impermanence: Ping timeout: 248 seconds

2017-11-13

[22:09:50] impermanence: has joined #ruby
[23:41:33] impermanence: Ping timeout: 250 seconds

2017-11-09

[17:27:40] impermanence: has joined #ruby
[20:35:56] impermanence: arr = [ "string1", ... , "stringN" ] ; def installer mod ... exec "command #{mod}" end ; arr.each { |e| installer e }
[20:36:02] impermanence: exec only runs once. why?
[20:37:42] impermanence: I can post a gist but I figure this is stupidly obvious on my end or something
[20:40:02] impermanence: jhass: huh. so subshell then?
[20:43:50] impermanence: dminuoso: yeesh, well, that answers what would've been my next question. Thanks!
[20:50:56] impermanence: it's working :) yay.
[23:23:45] impermanence: Ping timeout: 248 seconds

2017-11-06

[17:42:16] impermanence: has joined #ruby
[17:44:45] impermanence: Remote host closed the connection
[21:02:23] impermanence: has joined #ruby
[23:29:08] impermanence: Ping timeout: 240 seconds

2017-11-02

[13:20:03] impermanence: has joined #ruby
[14:17:07] impermanence: Ping timeout: 260 seconds

2017-11-01

[18:07:33] impermanence: has joined #ruby
[18:35:25] impermanence: I've installed this: https://github.com/postmodern/combinatorics and when I call Set['ab', 'cd', 'ef'].powerset I am returned #<Enumerator: #<Set: {"ab", "cd", "ef"}>:powerset> as opposed to what the documentation says powerset should return. Am I missing something here? I expected an array of objects...
[18:40:54] impermanence: lupine: oh, yep. I see now. calling each on the enumerator return has straightened me out.
[18:40:59] impermanence: if you were talking to me.
[18:48:55] impermanence: How do I access elements in a data structure such as: #<Set: {3, 5, 7}>
[18:51:45] impermanence: elomatreb: touch them to be used. they don't need to be mutated, deleted, nothing else.
[18:52:05] impermanence: I guess I should just use the Set methods it seems...
[18:54:03] impermanence: havenwood: iterate over all items
[18:54:12] impermanence: havenwood: looks like each is fine...
[18:55:22] impermanence: I suppose this ...each { |i| i.each { |j| p j } } is disgusting? :)
[18:55:56] impermanence: This at least prints out what I'm looking to do, essentially
[18:56:48] impermanence: which is iterate of every element in something like this: [[1,2,3], [1,2], [1,3], [2,3], [1], [2], [3]]
[18:59:46] impermanence: Is a nested each like that terrible? I would guess that if I have to do that then probably there is a better way to do what I want.
[19:07:03] impermanence: elomatreb: yep
[19:14:46] impermanence: elomatreb: this is specifically what I am trying to do: ...
[19:15:25] impermanence: elomatreb: one sec
[19:16:29] impermanence: if any of [1, 2, 3] are factors of some number, then begin to check if the subsets of such an array are also factors: [1, 2], [1, 3], [2, 3] ... etc.
[19:16:53] impermanence: I started thinking I would use Combinatorics#powerset
[19:17:10] impermanence: which I suppose I could...
[19:17:53] impermanence: but now, algorithmically I realize that if any of [1, 2, 3] are not factors then I don't even need to produce or check their corresponding subsets...
[19:18:42] impermanence: elomatreb: that makes [1,2].size of us :)
[21:45:52] impermanence: Remote host closed the connection

2017-10-31

[15:15:15] impermanence: has joined #ruby
[15:16:10] impermanence: I'm solving a coding challenge and in it there are some strings that I know will not change. What is the best Ruby practice on storing these?
[15:17:01] impermanence: I have also seen the method freeze used...(?)
[15:17:26] impermanence: magic comment?
[15:17:34] impermanence: Remote host closed the connection
[15:33:00] impermanence: has joined #ruby
[15:33:10] impermanence: Remote host closed the connection
[18:42:16] impermanence: has joined #ruby
[18:43:04] impermanence: Are there methods that handle modulo arithmetic?
[18:43:33] impermanence: e.g. is_divisible? or something similar? or is my only choice % ?
[18:45:42] impermanence: Numeric.modulo.
[18:51:24] impermanence: I assume that freeze works on Integers, as well? e.g. THREE = 3.freeze
[18:51:38] impermanence: seems to...although in pry I am allowed to reassign...
[18:51:44] impermanence: it throws a warning...
[18:53:38] impermanence: I have a small program that will be using some numbers and these numbers will be constants. Should I make them constants?
[18:53:51] impermanence: I was planning on doing like: THREE = 3.freeze
[18:53:53] impermanence: or is that stupid?
[18:57:05] impermanence: matthewd: out of curiosity why do you say that having a constant named THREE is stupid? Because of how uninformative the name is?
[18:58:31] impermanence: yeah, that's kind of what I thought you were implying. makes sense.
[19:00:14] impermanence: >> 3.object_id
[22:02:08] impermanence: Ping timeout: 248 seconds
[22:22:16] impermanence: has joined #ruby
[22:53:57] impermanence: Ping timeout: 240 seconds

2017-10-30

[16:19:59] impermanence: Remote host closed the connection
[16:20:17] impermanence: has joined #ruby
[22:04:41] impermanence: Ping timeout: 240 seconds

2017-10-15

[00:21:09] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client

2017-10-14

[08:09:17] impermanence: has joined #ruby
[08:23:45] impermanence: what's the best way to read a binary file in Ruby?
[08:24:04] impermanence: rn I'm using IO.binread...
[08:33:13] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[08:33:26] impermanence: has joined #ruby
[08:36:15] impermanence: matthewd: fair enough
[09:21:18] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[12:20:53] impermanence: has joined #ruby
[18:04:24] impermanence: has joined #ruby
[18:10:24] impermanence: I have a one-liner that is returning a value that is double-quoted. I'm trying to then pass this value to a hash, but it doesn't correctly access the hash I suppose to the double quotes around my value. Where am I going wrong here?
[18:10:44] impermanence: *because of the double quotes, that should have read
[18:16:33] impermanence: k, well change my hash keys to double-quoted instead of single has done the trick so far...

2017-09-18

[00:35:02] impermanence: has joined #ruby
[00:35:35] impermanence: Is there an easy way in ruby to return non-contiguous array elements? [1, 2, 3, 4] => [2, 4] ?
[00:37:23] impermanence: matthewd: cool, I figured so, but googling was a bit unclear. thanks!
[00:59:48] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[13:03:55] impermanence: has joined #ruby
[14:04:45] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[14:05:06] impermanence: has joined #ruby

2017-08-07

[00:16:00] impermanence: LiamW: hey. It loops through an array of string and counts same elements in a row, i.e. [1, 1, 2, 1, 2, 2] = 1: 2, 2: 1, 1: 1, 2: 2
[00:16:15] impermanence: yes I guess it is if that is what mapreduce means.
[00:16:22] impermanence: I've been wondering
[00:17:03] impermanence: I tried using a ternary but no love
[00:19:08] impermanence: havenwood: yeah (lamenting) that's what I was trying to head for, lol.
[00:25:21] impermanence: havenwood: your line moved my "algorithm" to one line, lol.
[00:25:48] impermanence: havenwood: some_array.chunk(&:itself).map { |k, v| Pair.new(first: k, second: v.size) }
[00:27:33] impermanence: LIamW: heh, it's an instantiation w/ two values is all. I edited code to remove what I at least thought were superfluous details.
[00:28:15] impermanence: LiamW: sorry, yes I know.
[00:28:24] impermanence: Pair is an API I guess.
[00:30:41] impermanence: LiamW: It's an exercise :|
[00:32:33] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[00:33:03] impermanence: has joined #ruby
[00:33:27] impermanence: chunk was exactly what I was looking. I'm going to read through Enumerable many times.
[03:23:31] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[11:13:56] impermanence: has joined #ruby

2017-08-06

[00:00:34] impermanence: apeiros: hey. I'm writing that now.
[00:02:21] impermanence: apeiros: I have a lambda. say exp = -> (a, b) { a**b } and a method that takes a lambda. say def my_method(m) ; my_method needs to return a new lambda like the original, but with the arguments flipped
[00:06:32] impermanence: apeiros: "very xy" ?
[00:07:09] impermanence: apeiros: oh, that was not my intention :)
[00:08:36] impermanence: apeiros: one sec, being specific.
[00:17:23] impermanence: apeiros: https://gist.github.com/jonassteinberg1/47578c67d83345605f3eda95c000640d
[00:23:46] impermanence: apeiros: I can be even more specific.
[00:25:43] impermanence: matthewd: oh, okay.
[00:26:59] impermanence: apeiros: are you wanting to know what problem I am trying to solve?
[00:30:03] impermanence: apeiros: no problem. I am trying to solve an exercise and am being asked to write a method that takes a lambda which itself takes two arguments, returns a new lambda like the original but with the two arguments flipped.
[00:32:03] impermanence: that's why I led off by asking if I could access lambda parameters from inside a function that takes a lambda is its one argument.
[00:33:19] impermanence: apeiros said that. at that point I started listening ;)
[00:37:58] impermanence: matthewd: -> (a,b) { f(b, a) }
[00:38:16] impermanence: I began working on this based on an earlier example from apeiros but
[00:38:38] impermanence: pry is throwing undef meth f
[00:43:13] impermanence: baweaver: ah, that makes sense.
[00:43:25] impermanence: baweaver: yes, I see now.
[00:43:53] impermanence: there we go :)
[00:45:11] impermanence: my understanding is that the dot operator access is new as of 2.4?
[00:51:35] impermanence: wow, the raganwald books are impressive.
[00:53:05] impermanence: apeiros: braking changes?
[02:58:39] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[03:51:42] impermanence: has joined #ruby
[05:25:33] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[12:25:42] impermanence: has joined #ruby
[13:34:59] impermanence: has joined #ruby
[13:41:14] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[17:41:29] impermanence: has joined #ruby
[17:53:13] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[22:09:23] impermanence: has joined #ruby
[22:09:29] impermanence: https://gist.github.com/jonassteinberg1/acd19aa51f475bdca4d1c6ce974f9d0f
[22:09:50] impermanence: ^ i know there is a more ruby way to do this, but unsure how to make it happen
[22:10:13] impermanence: also unsure how to get it to stop duplicating the last element
[22:43:59] impermanence: I've figured out the second part.
[22:44:09] impermanence: Now I'm just interested in rubifying this.

2017-08-05

[21:22:55] impermanence: apeiros: one sec
[21:28:52] impermanence: apeiros: I just did your line - backed_companies :)
[22:08:46] impermanence: Quit: http://www.kiwiirc.com/ - A hand crafted IRC client
[23:19:00] impermanence: has joined #ruby
[23:37:58] impermanence: Suppose I have a method that takes a lambda as an argument. This lambda has two parameters itself. Is it possible for me to access the lambda's parameters inside the method?