Activity Graph

Page 1 of 3 | Next »


[04:55:54] chrisseaton: Quit: Connection closed for inactivity


[16:17:06] chrisseaton: has joined #ruby


[15:04:56] chrisseaton: has joined #ruby
[15:05:11] chrisseaton: Does anyone have an interest in fibers and want to read a draft blog post?
[15:06:31] chrisseaton: Hah you're always there for me, haven wood!
[20:24:38] chrisseaton: Quit: Connection closed for inactivity


[01:38:11] chrisseaton: Quit: Connection closed for inactivity


[21:38:32] chrisseaton: has joined #ruby
[21:40:49] chrisseaton: Would anyone be interested in reviewing a RubyConf talk proposal for me? Could do with some completely external opinions on it.


[02:20:44] chrisseaton: has joined #ruby
[04:30:08] chrisseaton: Quit: Connection closed for inactivity


[11:06:31] chrisseaton: Quit: Connection closed for inactivity


[00:57:29] chrisseaton: mroutis: I want to let the user configure date formats using standard environment variables, but Ruby seems to ignore them.
[00:57:38] chrisseaton: Perhaps deliberately, based on these discussions.


[20:28:34] chrisseaton: *.net *.split
[23:22:09] chrisseaton: has joined #ruby
[23:25:17] chrisseaton: Does anyone know any resource on how Ruby interacts with locale environment variables? I can't see an impact on"%c") from changing LC_ALL. Should I?


[20:41:43] chrisseaton: Arney: there’s also a native version of TruffleRuby that doesn’t need jars or a JVM
[23:23:29] chrisseaton: Arney: we actually do have a lock on C extensions at the moment I'm afraid
[23:23:50] chrisseaton: I think (but not sure) that Rubinius doesn't have a lock on C extensions, so they must have made it work, but for us it just doesn't seem to work well on many C extensions
[23:27:55] chrisseaton: Arney: there's quite a lot of docs these days for Ruby users
[23:28:59] chrisseaton: Yeah... I'm afraid you need to 'sign up' to OTN to download it at the moment, because it's based on OracleJDK. There will be a standalone binary Ruby release soon that doesn't need a JVM and will be wget-able
[23:31:08] chrisseaton: If your code isn't faster in JRuby then ask them for help - they will be keen to fix it
[23:31:22] chrisseaton: I'm not saying GraalVM will be faster for you first time either
[23:32:08] chrisseaton: No I mean ask JRuby for help and they'll fix bugs in JRuby for you to make it fast for your code
[23:32:39] chrisseaton: It is possible to write code that will defeat almost any JIT though - such as repeatedly redefining methods - and sometimes people do seem to end up writing code that does that
[23:36:02] chrisseaton: pilne: if you like Ruby-in-Ruby then TruffleRuby is definitely for you - it's over half Ruby code
[23:36:44] chrisseaton: zenspider: you should poke around in our core and see how much you recognise now
[23:38:46] chrisseaton: Arney: if you mean just being literally, if you look at the code base, it's a lot of C++
[23:39:13] chrisseaton: Arney: well the VM is a pretty big bit of it...
[23:39:29] chrisseaton: baweaver: I interned in Redwood Shores in 2013, been working from home in Cheshire since
[23:39:53] chrisseaton: baweaver: it would be possible to write a Ruby to native compiler (you could write it in Ruby) and write your whole VM in Ruby
[23:39:59] chrisseaton: We have a whole JVM implemented in Java
[23:41:25] chrisseaton: Very experienced people like Cliff Click (one of the main Hotspot people) have said they don't think they'll ever write another VM in C++ again - we're past that as an industry
[23:43:27] chrisseaton: I think he meant people writing VMs in higher level languages
[23:43:52] chrisseaton: Well they'd be compiled to native
[23:44:15] chrisseaton: For instance PyPy is a Python interpreter written in Python and compiled to native code (simplifying for the sake of argument)
[23:50:46] chrisseaton: I think a problem is it's a lot of work to build a proper native compiler in your own language, for your own language, and at the end of it at best, it'll be functional because it's not going to do anything amazing, it'll just compile what you want


[04:11:06] chrisseaton: Read error: Connection reset by peer
[04:15:25] chrisseaton: has joined #ruby


[00:08:00] chrisseaton: Does anyone know common patterns for chaining signal handlers in Ruby? Installing the old signal gives you the new one as a return value, so it's hard to capture the old one in the closure for the block that you install as the new one, in order to call it.


[12:47:09] chrisseaton: has left #ruby: ()


[17:28:17] chrisseaton: bijan_: TruffleRuby has a much higher percentage in Ruby
[17:28:28] chrisseaton: (Probably depends a lot on how you count it)
[17:29:13] chrisseaton: No I was actually here just about to ask a question this time!
[17:29:40] chrisseaton: Does Ruby have any way to define a 'virtual' global variable? As in it looks like one but you supply your own callbacks to give the value? I'm sure I remember it does, but can't find it now.
[17:30:12] chrisseaton: Is the patch somewhere online?
[17:32:06] chrisseaton: Yeah we're writing something up on all these 'global' variables
[17:34:27] chrisseaton: Thank you very much!


[22:05:43] chrisseaton: *.net *.split
[22:06:53] chrisseaton: has joined #ruby


[11:09:27] chrisseaton: oshanz: a JIT should really help meta-programming - make it as fast as normal programming
[13:59:53] chrisseaton: ShalokShalom: what was before MRI in 1.7 and before then?


[02:37:32] chrisseaton: Ping timeout: 272 seconds
[02:38:53] chrisseaton: has joined #ruby


[18:37:26] chrisseaton: Are frozen string literals garbage collected?
[20:14:27] chrisseaton: apeiros: string constants at the top level of a file for example - think of all those require statements!


[01:53:06] chrisseaton: Read error: Connection reset by peer
[01:53:36] chrisseaton: has joined #ruby


[19:14:27] chrisseaton: Ping timeout: 250 seconds
[19:43:18] chrisseaton: has joined #ruby


[19:30:08] chrisseaton: dminuoso: JRuby integers are allocated on the heap - there is a Graal phase Charlie wrote to escape analyse them though
[19:30:53] chrisseaton: They’re also allocated on the heap in Truffle but our local escape analysis for that is pretty much perfect
[19:32:06] chrisseaton: (as we do a full partial evaluation)
[19:41:29] chrisseaton: And actually I think JRuby might do some EA in their IR but it’ll be more limited
[20:04:45] chrisseaton: Basically, but the object isn’t really ‘allocated’ on the stack - instead all fields are turned into data flow edges and any unused fields disappear
[20:05:16] chrisseaton: So for a boxed integer the value is passed directly and the object goes away entirely
[20:08:57] chrisseaton: No I mean in general any data structure in a compiler that links where a value is produced to where it is used
[20:09:27] chrisseaton: In Truffle it literally is an edge, as Graal uses a free flowing graph data structure
[20:10:53] chrisseaton: So an edge for an integer value from instruction A, into a boxing operation, into an unboxing operation, to instruction B, becomes a single edge shortcutting right from A to B, as the boxing and unboxing cancel out
[20:11:15] chrisseaton: And then the best it is the box and unbox operations just disappear from the program
[20:11:27] chrisseaton: As nobody points to them any more
[20:17:34] chrisseaton: It’s a graph, not an AST style tree
[20:18:21] chrisseaton: An AST does things like read and write local variables by name, the graph has no local variables - if you set a name and then read it that becomes an edge in the graph
[20:19:07] chrisseaton: This means lots of implicit things - like ordering a read after a write to the same name - become explicit in the data structure so you have more control over it
[20:22:06] chrisseaton: Compilation at runtime is almost exactly the same as compilation ahead of time. Apart from maybe wanting to be quicker there’s no need to do much different.
[20:22:38] chrisseaton: No we use just an AST for interpretation, graph is only for compilation
[20:23:15] chrisseaton: Our philosophy is simple interpreters which are easy to maintain, and then do compilation automatically from the interpreter
[20:27:23] chrisseaton: Yes Graal does the deopt map automatically and deopt puts you back in the interesting with a reconstructed stack
[20:28:35] chrisseaton: I’m trying to write a blog post showing how this works using pure Ruby, but can’t find the time
[20:32:17] chrisseaton: Yeah that’s what I’m going to try to finish off this holiday week


[13:30:03] chrisseaton: elisaado: MRI can do parallelism, only if the parallel part is written in C (or some other language usable from a C extension)


[23:57:37] chrisseaton: Ping timeout: 258 seconds
[23:59:43] chrisseaton: has joined #ruby


[14:48:11] chrisseaton: *.net *.split
[14:54:17] chrisseaton: has joined #ruby


[02:28:53] chrisseaton: has joined #ruby


[21:51:52] chrisseaton: Ping timeout: 255 seconds


[12:33:17] chrisseaton: Bish: Rubinius removed their JIT, and despite planning to write a new one in a couple of weeks, we still don't have one about a year and a half later
[12:34:03] chrisseaton: Bish: until they put the JIT back in, it's slower than MRI
[12:35:12] chrisseaton: Personally I think removing it without a replacement was a mistake, and it was never going to be possible to implement a new JIT in a couple of weeks, but then I don't have to maintain it. I think that was their complaint - they found it too hard to work on the JIT.
[12:36:12] chrisseaton: I think there are still people trying - doesn't GitLab have Yorick Peterse working one day a week on it? And there's now a company behind it as well.
[12:36:44] chrisseaton: It's still useful if you are doing things that don't need high performance.
[12:41:33] chrisseaton: Bish: a faster interpreter is possible - there is a lot of research into how to do this - but Rubinius is written in Ruby so it needs to be not just a bit faster but a lot faster
[12:42:44] chrisseaton: Bish: MRI doesn't just need a JIT, it needs an extremely good JIT to optimise Ruby. That's the issue - it's not a linear return on investment, it's a huge cost with no benefit until you have a really sophisticated JIT. I gave a lecture on why this is
[12:43:27] chrisseaton: Bish: but the core library is written in Ruby in Rubinius, so operations that were native C code and now running in the interpreter as well - the interpreter has to do more, so even if it was faster it needs to be a lot faster
[12:44:44] chrisseaton: I canonical example I give is `[a, b, c].sort[1]` - a normal JIT doesn't help you make that kind of code fast, because it's just calls to other methods. You need. JIT that is powerful enough to see into and through all those method calls, eliminate all those objects, and so on, to do well on Ruby.
[12:45:26] chrisseaton: A JIT that does the usual things like making local variables fast and calls fast isn't good enough for Ruby.


[18:15:52] chrisseaton: If I have a string A, and want to replace all instances of some other string B, with string C instead, how should I best do that in Ruby? C may contain anything, so String#gsub won't work.
[18:21:59] chrisseaton: I want to do a.gsub(b, c)
[18:22:06] chrisseaton: All are strings
[18:22:27] chrisseaton: But c could contain any string at all, so could include back-references, which I don't want evaluated as a regexp
[18:23:45] chrisseaton: >> 'foo'.gsub('f', '\0')
[18:24:16] chrisseaton: 'foo'.gsub('f', '\0') -> "foo"
[18:24:25] chrisseaton: I want '\0oo'
[18:27:22] chrisseaton: I'm sure I must be overlooking some methods... surely there must be a core library method to do something as simple as substitute a string...
[18:31:06] chrisseaton: Ah clever, thanks


[02:13:59] chrisseaton: *.net *.split


[15:52:57] chrisseaton: kitallis: do you need it to be very fast?
[15:56:48] chrisseaton:
[15:57:28] chrisseaton: Java will intrinsify that to actually use the lzcnt instruction, but Ruby won't
[15:57:45] chrisseaton: That's probably reasonably fast for Ruby
[15:58:37] chrisseaton: Something a bit more Ruby-like and high level but slow could be n.to_s(2).rjust(width, '0').chars.take_while{ |c| c == '0'}.size
[16:01:25] chrisseaton: kitallis: this code references something called 'HD' but I don't know what that is
[16:06:44] chrisseaton: kitallis: you probably want to use >> in Ruby, instead of >>>
[16:08:04] chrisseaton: (of course, take note of the copyright and licence of this file when copying it etc etc)
[16:39:25] chrisseaton: kitallis: ok but that won't work for some integers of course - not all integers fit in a double
[16:44:37] chrisseaton: It can do that large yes, but not with that much precision
[16:45:01] chrisseaton: I think a Ruby Float will be able to represent an integer op to 2**56
[16:50:36] chrisseaton: A Ruby Float is an IEEE double, which has 56 bits of precision
[16:53:18] chrisseaton: irb(main):037:0> 0b11111111111111111111111111111111111111111111111111111.to_f.to_i.to_s(2)
[16:53:19] chrisseaton: => "1000000000000000000000000000000000000000000000000000000"
[16:53:19] chrisseaton: irb(main):038:0> 0b111111111111111111111111111111111111111111111111111111.to_f.to_i.to_s(2)
[16:53:19] chrisseaton: => "11111111111111111111111111111111111111111111111111111"
[16:53:54] chrisseaton: See - the 55th bit is lost
[16:54:08] chrisseaton: I'm not immediately sure why it isn't 56th - I'm not an expert on floating point numbers really
[16:55:17] chrisseaton: What I'm saying is that you convert an integer rather than 55 bits into a Float, you don't always get the exact integer - you get something close to it
[16:55:27] chrisseaton: There's no negative numbers here
[16:56:11] chrisseaton: This explains in the context of JavaScript
[16:57:07] chrisseaton: It says that the maximum integer you can store in a Float without loss of precision is 9007199254740991, or 0x1FFFFFFFFFFFFF
[16:59:02] chrisseaton: Another example:
[16:59:13] chrisseaton: => "200000000000000000"
[16:59:13] chrisseaton: irb(main):049:0> 0x1FFFFFFFFFFFFFFFFF.to_f.to_i.to_s(16)
[16:59:13] chrisseaton: => "1fffffffffffff"
[16:59:13] chrisseaton: irb(main):048:0> 0x1FFFFFFFFFFFFF.to_f.to_i.to_s(16)
[16:59:23] chrisseaton: See how it's had to approximate the second number - it's lost precision
[17:20:32] chrisseaton: Right - because the fixed (as opposed to floating) part of Float is 53 bits. Then there are more bits for the sign and the floating part, but you aren't using those so they just go to waste.


[00:17:32] chrisseaton: *.net *.split


[13:24:01] chrisseaton: konsolebox: no MRI's never had a JIT merged into it - there have been some experiments though


[07:46:49] chrisseaton: has joined #ruby


[16:11:36] chrisseaton: Does Spec provide some convenient way to run Ruby sub-processes and examine the output?
[16:24:24] chrisseaton: spiette: thanks, but those look like they don't actually start a new process which is what I want to do
[16:26:48] chrisseaton: I'll just run RbConfig.ruby
[16:39:00] chrisseaton: spiette: thanks, but again that's the opposite of what I want - the pretends to launch a new process but doesn't. I want to run a new process because I want to test interactions with the process.
[16:39:12] chrisseaton: spiette: I'll just use system and RbConfig.ruby directly


[14:05:46] chrisseaton: Why can't we define finalisers for symbols, now that symbols are subject to garbage collection?
[14:06:48] chrisseaton: And why can't we define finalisers for large (heap allocated) integers?
[14:12:10] chrisseaton: I'm doing some interop with native code, and want a native handle to refer back to symbols. I can't use _id2ref, as I want JRuby compatibility. So I build a map of object to handle, and I want to remove the entry in the map when the object is collected.
[14:12:18] chrisseaton: Ah! Maybe I should be use a weak reference instead.
[14:13:02] chrisseaton: Nope, you can't have weak references to symbols. Can't see why that is a rule either.


[19:29:52] chrisseaton: You know %{foo bar} syntax for an array of strings? Is there something similar for an array of symbols?
[19:31:01] chrisseaton: al2o3-cr: genius! thank you


[13:49:20] chrisseaton: has joined #ruby


[02:15:12] chrisseaton: Quit: Connection closed for inactivity


[20:11:34] chrisseaton: has joined #ruby


[21:00:36] chrisseaton: has joined #ruby
[21:01:08] chrisseaton: Hi does anyone have a good understanding of the relationship between Digest and OpenSSL::Digest? The later just subclasses the former, right? Why is it like that?
[21:04:21] chrisseaton: I have `cDigest = rb_define_class_under(mOSSL, "Digest", rb_path2class("Digest::Class"));`, but I'm just not sure of the history of all this
[21:52:21] chrisseaton: has left #ruby: ()


[22:04:09] chrisseaton: has left #ruby: ()


[13:29:10] chrisseaton: I don't think it's anything about LLVM that limits it for JIT, but it just doesn't solve the problems you have with a JIT. LLVM helps you emit great low-level code, but if you don't know what code you want to emit it won't help you do that.
[13:29:48] chrisseaton: Rubinius for example emitted LLVM pretty directly 1-for-1 from Ruby code, and LLVM is just never going to optimise that. It doesn't know enough, the code is too low level already, and it wasn't designed to do that at all.
[13:30:12] chrisseaton: Not stalking, just interested in any discussions on JITing Ruby
[13:32:25] chrisseaton: I mean if you emit an LLVM call to malloc, and then read and write a field in that object, LLVM is never going to be able to realise it could just link the read to the write directly and never call malloc.
[13:32:43] chrisseaton: It will always just do exactly what you told it to do - call malloc - and can't make decisions to do things like remove that call
[13:34:23] chrisseaton: I wouldn't say 'just limited to' because it's still extremely good for it, but yes that's what it does
[13:34:42] chrisseaton: You need to already have optimised your language to the point where you could emit machine code yourself, and then LLVM just helps you emit good machine code
[13:35:33] chrisseaton: You can see lots of examples of people realising this - the FTL backend in Safari had a JS IR and then emitted LLVM instead of their own machine code, the MIR for Rust where before I think they just used LLVM directly, etc
[13:41:43] chrisseaton: C and C++ are already low level though
[13:42:01] chrisseaton: Transforming Ruby code to the point where it's like C is the problem
[13:44:39] chrisseaton: morfin: yes, and those things are in the domain where LLVM does well
[13:45:16] chrisseaton: And actually Rubinius doesn't even use LLVM for its JIT any more
[13:48:32] chrisseaton: Not for the past year or so, no
[13:49:07] chrisseaton: They were talking about possibly using OMR (which is a tiny bit like IBM's version of something like Graal)


[21:32:43] chrisseaton: Hi is there a Ruby metaprogramming method to get and set global variables?
[21:42:29] chrisseaton: havenwood: I'll do an eval then
[21:48:48] chrisseaton: baweaver: I'm implementing Ruby C extensions using Ruby, so I need to do something to implement rb_gv_get and rb_gv_set, there's not really any other way around
[21:49:06] chrisseaton: baweaver: I'm not recklessly using metaprogramming for the sake of it
[21:52:34] chrisseaton: baweaver: plus I have a fast version of eval, so it shouldn't be slower than having the code literally in the source file, and I'll use a binding for the value for gv_set, so it should be hygienic too
[22:00:01] chrisseaton: dminuoso: objdump as in the command line binary tool? I'm running on my own Ruby VM so it won't be binary compatible like that, but go on...
[22:01:06] chrisseaton: dminuoso: to call rb_gv_get and _set? I don't have those functions - they're the ones I'm trying to implement in the first place
[22:02:17] chrisseaton: dminuoso: yeah, I'm doing an implementation of the Ruby cext API using Ruby itself
[22:04:24] chrisseaton: dminuoso: that would be useful for writing specs for the cext API - at the moment ruby/spec sort of does that manually, and it's horrible


[08:01:29] chrisseaton: Ping timeout: 250 seconds
[08:02:49] chrisseaton: has joined #ruby


[17:48:01] chrisseaton: Where do people go for capi documentation? I can't seem to find any really
[17:48:32] chrisseaton: I can figure most of it out by reading the source, but some of it is a mystery
[17:48:59] chrisseaton: rb_cloexec_fcntl_dupfd is puzzling me at the moment
[17:51:30] chrisseaton: what it does basically
[17:53:25] chrisseaton: drbrain: here we go - Rubinius has it implemented simply as 'return fcntl(fd, F_DUPFD_CLOEXEC, 3);' - that I can understand!


[15:14:45] chrisseaton: I wouldn't recommend using it in production yet - we don't have things like openssl yet
[15:15:54] chrisseaton: Maybe the first half of next year
[15:16:17] chrisseaton: But if you tell me what your app does and what libraries you use I can say if there's any blockers on that
[15:16:38] chrisseaton: We're working on a system to test all gems on JRuby+Truffle, so we can tell you if your app should work based on your dependencies
[15:18:46] chrisseaton: We pass all of the ActiveSupport, ActiveModel and most of the ActionPack specs, so we're getting there quickly
[15:19:08] chrisseaton: ActiveView and Railties basically work, but not all the specs pass
[15:19:27] chrisseaton: But we pass more language specs than JRuby or Rubinius do
[15:20:19] chrisseaton: dunpeal: well they're accurate for those benchmarks
[15:20:33] chrisseaton: I'm not sure how much faster an off the shelf Rails app is going to be
[15:20:51] chrisseaton: But Truffle does best on programs with lots of small intermediate arrays and hashes and lots of string concat, and that's what Rails apps do
[15:21:13] chrisseaton: dunpeal: most of those benchmarks are from ChunkyPNG and PSD.rb, which are really gems people are running in production today
[15:23:41] chrisseaton: jhass: I don't have numbers against MRI, but let me just check out CI which compares against JRuby...
[15:24:57] chrisseaton: jhass: we use about 3x the heap that JRuby uses
[15:25:16] chrisseaton: Sorry, it's very hard to measure that
[15:25:36] chrisseaton: You can't just compare RSS, because the way that the JVM works is it will use as much heap as you give it
[15:26:05] chrisseaton: Maybe 4 or 5x at the moment?
[15:26:21] chrisseaton: So yeah, you may need a larger instance, but you should be able to serve many more requests much quicker with that bigger instnace
[15:26:45] chrisseaton: You mean if you have a surge and then it goes back down? Sorry I don't know
[15:27:23] chrisseaton: tenderlove was making fun a while ago of a comment I made about how adding more memory to a server is easy. My argument is that at the moment how can you reduce the response time for individual customers?
[15:27:30] chrisseaton: You can't buy a faster processor, as we don't really have those any more
[15:27:43] chrisseaton: You can't use more than one processor or core for a single request, as we can't program that well to do that
[15:27:57] chrisseaton: The only degree of freedom you have is you can add more RAM - you can add as many GB of RAM as you want
[15:28:04] chrisseaton: It scales perfectly
[15:28:11] chrisseaton: So let's use that RAM to improve the performance of Ruby
[15:28:37] chrisseaton: What I hope to do in the future is to run web request benchmarks on different size droplets and AWS instances, and say on each instance how much faster it is, or if the instance is too small
[15:29:45] chrisseaton: Papierkorb: well servers that large are fine - it's the people running 512 MB DO droplets who may be disappointed the Truffle probably won't run fast there
[15:31:13] chrisseaton: I guess if Ruby is too slow for you, you're probably already running on many DO droplets, and we'd say that Truffle will make it fast, but you might need just one bigger droplet
[15:31:56] chrisseaton: Truffle uses a lot of memory to compile, but the other side of it is when the compiled code runs it uses much less memory. So hopefully for lots of concurrent clients it will balance out
[15:32:28] chrisseaton: Eg a Rails view will allocates MB of heap for each request normally could run allocating hardly anything after our optimisations, so actually save heap
[16:24:49] chrisseaton: dunpeal: not all the language specs make a lot of sense but we did them all to show we could
[16:25:35] chrisseaton: dunpeal: I don't think rubinius has a JIT any more, and I never found it be very fast even when it did
[16:38:33] chrisseaton: dunpeal: no because there's also core library specs and we don't pass all of them
[16:42:57] chrisseaton: We're solving the Java startup time by having a statically compiled version of JRuby Truffle so there no need to have a JVM installed even
[17:08:39] chrisseaton: It's a few hundred MB for the standalone binary
[17:09:05] chrisseaton: You compile in any Java libraries you need, but you can load C exts at runtime
[20:57:22] chrisseaton: mustmodify: I think you want their Gitter channel nowadays


[18:39:10] chrisseaton: dminuoso: hello
[18:39:59] chrisseaton: dminuoso: you understand that a C program and a Ruby program could have the same output but the C program be much simpler and so much faster? Well that's because the Ruby interpreter does things in a more complicated way than necessary. Our JIT tries to figure out what work isn't needed and avoids doing it.
[18:40:37] chrisseaton: dminuoso: I presented a deliberately extreme example in this blog post (half way down, 'The Acid Test')
[18:41:00] chrisseaton: dminuoso: the output of this benchmark is 22, but you can see how much Ruby code runs to work that out
[18:41:35] chrisseaton: dminuoso: a JIT can think about all that Ruby code, and simplify it to the single value 22, and output a single machine instruction to return that result, instead of executing any code (I'm simplifying, it's not quite like that in reality)
[18:42:31] chrisseaton: dminuoso: if you are still interested in knowing more I can talk you through some more examples in DM


[12:40:25] chrisseaton: Anyone interested in JRuby+Truffle? Like talk on Graal (the wider ecosystem around it) about to start here
[12:40:57] chrisseaton: Live talk, not like talk
[12:44:01] chrisseaton: dminuoso: 30 mins I guess
[12:45:23] chrisseaton: dminuoso: had some bigger fish to fry for a while, still working on it though


[17:19:43] chrisseaton: Ping timeout: 250 seconds
[17:20:24] chrisseaton: has joined #ruby


[05:00:00] chrisseaton: *.net *.split
[08:54:03] chrisseaton: has joined #ruby


[23:19:02] chrisseaton: Sorry, it's actually the replacement parameter that is giving me problems "If replacement is a String it will be substituted for the matched text. It may contain back-references..."
[23:20:38] chrisseaton: 'foo'.gsub('f', '\\0') -> "foo"
[23:22:52] chrisseaton: is there a stdlib method for escape regex like that then?