01:12 <travis-ci> jruby/jruby (master:888673f by Charles Oliver Nutter): The build was fixed. https://travis-ci.org/jruby/jruby/builds/694473798 [145 min 22 sec]

01:59 <travis-ci> jruby/jruby (master:d6686d0 by Charles Oliver Nutter): The build was broken. https://travis-ci.org/jruby/jruby/builds/694485648 [29 min 55 sec]

01:59 <headius[m]> stupid maven

02:08 <travis-ci> jruby/jruby (master:04f7d80 by Charles Oliver Nutter): The build was broken. https://travis-ci.org/jruby/jruby/builds/694486036 [36 min 24 sec]

02:11 <travis-ci> jruby/jruby (master:0275f6f by Charles Oliver Nutter): The build was broken. https://travis-ci.org/jruby/jruby/builds/694486191 [36 min 16 sec]

02:12 <headius[m]> shaddap

02:13 <headius[m]> I'd turn those off but I don't get failed build notifications other ways (email is not noisy enough)

02:16 <travis-ci> jruby/jruby (master:e5d98e4 by Charles Oliver Nutter): The build is still failing. https://travis-ci.org/jruby/jruby/builds/694487866 [34 min 17 sec]

02:21 <travis-ci> jruby/jruby (master:bcd8a58 by Charles Oliver Nutter): The build is still failing. https://travis-ci.org/jruby/jruby/builds/694488736 [34 min 30 sec]

06:15 <jmalves> @rg[m] the idea is to not allow other threads to enter for example the "synchronized" methods in that object. I could refactor ofc the java class to use an explicit mutex but I was wondering if this is possible to do from ruby without having to change the java class.

06:31 <headius[m]> Jason Rogers: did anyone reply to you?

06:31 <headius[m]> could be that something we're doing uses more stack than it should but 23M is extreme

06:32 <headius[m]> if you haven't already I'd open an issue and give us something to repro

06:32 <headius[m]> jmalves: I think I missed this conversation

06:32 <jmalves> Hey headius! My question was if is there a way to do the equivalent of `synchronized (object) { }` in ruby?

06:33 <headius[m]> without an explicit Ruby Mutex object, I assume

06:33 <jmalves> Yes

06:33 <headius[m]> there's nothing built-in unfortunately

06:34 <jmalves> Ok, I guess one can always have a java helper method that can be called from ruby that does this so it is not a big deal

06:34 <headius[m]> I have thought about adding something that would let you use the built-in object monitor, like say "JRuby.synchronized(object) { }"

06:34 <headius[m]> yah basically that

06:35 <headius[m]> we have a couple similar things to allow using JVM locking but have never really promoted them in favor of using compatible options

06:37 <headius[m]> there is a way to do it for a whole object but it's via a module

06:37 <headius[m]> require 'jruby'; obj.extend(JRuby::Synchronized) basically makes all method lookups get wrapped with synchronization against the object

06:38 <headius[m]> but extend has its problems, and of course this does it for EVERY method call to that object

06:38 <headius[m]> I like the idea of adding JRuby.synchronize or synchronized

06:39 <jmalves> Does this `obj.extend(JRuby::Synchronized)` also synchronize from the java side?

06:39 <headius[m]> that's all it does

06:40 <headius[m]> it just injects some code into method lookup that wraps "my method" with "synchronized(thatObject) { myMethod.call }"

06:40 <headius[m]> basically

06:40 <jmalves> ah ok

06:45 <jmalves> If there was such a "JRuby.synchronize" or "synchronized" how would it work if someone passed a ruby object and not a java one to it?

06:46 <headius[m]> Ruby objects are Java objects

06:46 <headius[m]> this would basically add the functionality

06:47 <headius[m]> it would probably make sense to also add "wait" and "notify"

06:47 <jmalves> Ok right

07:13 <headius[m]> so weird, I must have used "synchronized" thousands of times in Java and yet I just had to double check it's synchronized(object) and not synchronize(object)

07:23 <jmalves> Unrelated but I have the same thing with "git --ammend" vs "git --amend" never remember which is the correct one :X

07:23 <headius[m]> hah yeah similar

07:47 <headius[m]> https://github.com/jruby/jruby/pull/6264

07:48 <headius[m]> it will need some tests, so if you feel like it you might make some

13:03 <JasonRogers[m]> > if you haven't already I'd open an issue and give us something to repro

13:03 <JasonRogers[m]> Thanks, @headius. I'll try to reproduce the problem in a similar fashion that isn't tied to the company's IP.

20:53 <headius[m]> perfect

22:37 <headius[m]> well we have a conundrum

22:37 <headius[m]> our caching of jar contents is not safe across multiple runtimes, but we store the caches globally