Chris Seaton

In some situations that's just not an option because once you've acquired the skill you now need to be paid for the skill in order for this system to be at all fair. That's also not saying anything about the feasibility of turning the average engineer into, for example, a chrisseaton [0] in a few months. The deal from the employer sounds bad: "Ok we need you to become an expert in X by Y to meet deadline Z. If you can't become an expert in X just do your best so we are able to hit deadline Z! Don't worry! You'll have a bunch of time in the future to maintain it!" [0] - https://chrisseaton.com/

Internet Archive. Does anyone know how to recursively save his entire website to Wayback Machine? I submitted https://chrisseaton.com, but it doesn't appear any of the child pages are being archived.

I'm sorry for your loss then. We followed each other on Twitter and I tried to plug the TruffleRuby and Graal work wherever I could as I really believed it is the future of Ruby. Beyond that what a brilliant writer. This single article helped me understand so much more about a language I've cherished for nearly two decades: https://chrisseaton.com/truffleruby/deoptimizing/

His personal website for those, like me, who didn't know the name. https://chrisseaton.com/ Even without knowing of him, this is incredibly tragic and my condolences to all of those affected.

>wants to fight about politics or other wedge issues It's always so funny that this is brought up on HN as a reason for lack of socialization or problem so often. One of the biggest and most durable parts of my social life is being a member of a political party, which I have been in since I was 16 years old. Being involved in civic/political life means you have connections with people from all walks of life across all generations and backgrounds. just wanting to chill is the actual problem because I don't think these suburban soccermom type social circles sustain meaningful relationships. Participating in public life is the most straightforward way to build social relationships that matter. There was another great post here a few weeks ago from someone explaining why he continues to serve in the British Yeomanry. https://chrisseaton.com/army/

I wonder if future work might support C Extensions in the same was as the jruby truffle / graal implementation plans to do. Here's a great article from a couple of years ago by Chris Seaton on this topic. http://chrisseaton.com/rubytruffle/cext/

EDIT: The man himself made a post: https://news.ycombinator.com/item?id=13058481 I wish it could be summarised in a comment, but it's actually not "that simple," so I recommend you read Chris Seaton's posts about GraalVM and JRuby+Truffle which has some excellent high-level explanations [of why Graal is amazing]. :) http://chrisseaton.com/rubytruffle/

http://chrisseaton.com/rubytruffle/deoptimizing/ mentioned above gives an excellent explanation. I was completely confused by the name. "In Ruby..." [we could have]... " deoptimization. It allows us to reverse the just-in-time compilation process and go back to a simpler interpreter where all the checks Ruby needs are explicit, all the objects really exist, and we have code paths to handle anything." It seems like Ruby has a whole lot of features that actually make optimising it very difficult (monkey patching et al), and this is their attempt to work around it.

I don't know Ruby, so I had never paid JRuby any attention or heard of any of this, despite writing VMs for fun and following PyPy development. This talk was amazing. The fact that you include a C parser and interpreter (CTruffle) [1], can parse (some) MRI Ruby extensions written in C, and treat it just same as Ruby and inline/partially evaluate/etc everything together, and hence run faster than compiled C extensions, is just mind blowing. And it's all JIT compiled to JVM bytecode which then gets JIT compiled by HotSpot, what an incredibly complex stack. [1] http://chrisseaton.com/rubytruffle/cext/ It makes me wonder about writing a JIT compiler to produce LuaJIT bytecode, since I'm currently working on AOT compilation of a dynamic language to LuaJIT bytecode.

This is correct, I would highly highly recommend reading "Deoptimizing Ruby" available here, http://chrisseaton.com/rubytruffle/deoptimizing/ for more information on WHY making Ruby fast is hard and what the Truffle+Graal does to make it fast.

If you are a Java developer and find PyPy amazing, you should also look at Truffle and Graal http://lafo.ssw.uni-linz.ac.at/papers/2013_Onward_OneVMToRuleThemAll.p… http://chrisseaton.com/rubytruffle/, https://bitbucket.org/ssllab/zippy/src/700f88dc2a7d2011258ae6f6e0b0fe3…

Truffle/Graal are both amazing technologies, I thought LLVM was amazing but Truffle blows my mind. You can write optimizing JIT compilers by actually just writing an interpreter in Java with some special tricks. And Truffle can do some amazing things with cross-language that aren't related to debugging, see http://chrisseaton.com/rubytruffle/cext/

I hope that the "pinning" work in the GC code is a first step for better CPython extension support. Classic C interop requires that some memory pointed from the C side in the Python heap stores the same thing. i.e. is not moved. Pinning is one way to do this. Otherwise the same idea that Jruby/Graal did with co interpreting C code can work for PyPy as well (http://www.chrisseaton.com/rubytruffle/cext/). Although that would need someone to step up and implement a RPython C interpreter, which to be honest is not a trivial exercise.

While probably less common in Java, the language supports dynamic class loading, reflection, runtime bytecode generation, invokedynamic, and other features that can break static assumptions. The JVM does need to deal with all of this and does so with speculative optimization and deoptimization. TruffleRuby applies many of these same techniques to Ruby to great effect. Fortunately, most applications stabilize at some point and a JIT compiler can do wonders. E.g., TruffleRuby has had zero-overhead metaprogramming for a decade now[1]. But, these optimizations incur trade-offs. TruffleRuby has a Ruby core library mostly written in Ruby to help optimization, but that means the interpreter takes a performance hit. The CRuby VM has most of its core library written in C because the team favors having a fast interpreter with low overhead, which is great, but means much of the core library can't be JIT compiled alongside an application. I think the real answer why the CRuby VM lags behind the JVM is more pedestrian: there's been orders of magnitude more investment made into the JVM than any Ruby VM. Sun and then Oracle have hired world class VM developers and researchers to work on multiple JIT compilers, multiple GC implementations, fast tooling, a standard memory model, world-class concurrency library, and so on. OpenJDK sees heavy investment by many others, too (RedHat probably leading the charge). And then you have other vendors advancing the state of the art with alternative VM…

JIT has little to do with interoperation. It's quite simple to generate C symbols pointing to stubs. What makes interoperation hard is usually a GC rather than a JIT (it's just that most JITted languages also employ a GC; but if you look at, say, Go, it's just as hard to embed or link against than as and it doesn't employ a JIT at all -- its runtime "just" performs scheduling and GC). --- BTW, Java can be embedded in scripting languages because those languages run on the platform itself and share the runtime. Because of the JIT -- that optimizes across libraries and languages -- the interoperation is cheaper than with C. So much so, that you get the following story: As part of the work being done at Oracle on Graal, HotSpot's next-gen JIT, they've ported various scripting languages to the new JIT, among them Ruby. They've found[1] that if they interpret/JIT the C code of the native Ruby extensions they get better performance than a "plain" Ruby runtime calling into statically compiled C, because the JIT is able to optimize across the language barrier. [1]: http://www.chrisseaton.com/rubytruffle/cext/

I really enjoyed reading Chris's deep dives on Ruby internals. This one to be specific. https://chrisseaton.com/truffleruby/rubykaigi21/ Rest in peace.

I believe the term for this is "partial escape analysis" (PEA). GraalVM is the SOTA in the JVM world for this. Here's an oldish blog on this: https://chrisseaton.com/truffleruby/seeing-escape-analysis/ I'm sure PEA is better now, but it's not sure if it's moved beyond scalars (int, float, etc.)

they are for Truffle-based language implementations https://chrisseaton.com/rubytruffle/pldi17-truffle/pldi17-truffle.pdf

You can do fake pointer arithmetic which won't hurt this use case (server-side web framework); if you implement Gforth as an interpreter on the JVM/CLR or running it with Emscripten, there is no issue for server-side web frameworks like this while being safe. That's been done for C a few times (this [0] and there are a few others); if you don't depend on the actual physical memory addresses you are using (which, in embedded, you often are counting on, but not in a server-side framework). > it's more a a cultural thing than a technical thing. I agree with that > IMO this era wants to build reliability from lots of unreliable parts, and that include developers; cowboy programmers who could make reliable things by themselves have been retired. Not sure what this means? [0] https://chrisseaton.com/plas15/safec.pdf

His dissertation about Ruby: https://chrisseaton.com/phd/specialising-ruby.pdf

Desperately sad news. I never met him, he never met Me, but https://chrisseaton.com/army/ made a real impression on me. It’s the kind of thing that sits in your head and pops up from time to time. I found the level of dedication here alongside his professional success incredibly inspiring. Tragically, part of that article is about his young daughter. Not really sure what to think now.

Yes you can, that is what compiler intrisics are for. https://chrisseaton.com/truffleruby/jokerconf17/

It doesn't seem to be mentioned here, but I'm especially intrigued by the possibility of implementing shaped objects. See https://chrisseaton.com/truffleruby/rubykaigi21/ and the previous HN conversation here: https://news.ycombinator.com/item?id=28476654 Shaped objects (aka Self's maps or JavaScript hidden classes) are an old idea, but they seem to have been only recently rediscovered, and the basic idea suddenly allows a lot of other potential optimizations (where research would be helpful). We don't know if they'd really improve Ruby performance, but I think it's very likely & I suspect they'd also enable future improvements.

Off the top of my head something like https://chrisseaton.com/truffleruby/ropes-manlang.pdf https://static.googleusercontent.com/media/research.google.com/en//pub… https://www.reddit.com/r/programming/comments/wewx2/allocation_sinking…

One weird operator that comes to mind is the flip-flop operator, but the odds of encountering it are close to zero, and it would certainly stick out as something very bizarre and not confused with other syntax. https://chrisseaton.com/truffleruby/flip-flops/

source: https://chrisseaton.com/truffleruby/ > TruffleRuby started as my internship project at Oracle Labs in early 2013. It is an implementation of the Ruby programming language on the JVM, using the Graal dynamic compiler and the Truffle AST interpreter framework. TruffleRuby can achieve peak performance well beyond that possible in JRuby at the same time as being a significantly simpler system. In early 2014 it was open sourced and integrated into JRuby for incubation, then in 2017 it became its own project, and now it is part of GraalVM. Since 2019 Shopify has sponsored development. > In early 2014 it was open sourced and integrated into JRuby for incubation Additionally, we also tried Truffle when it was JRuby, or in JRuby, however you want to put it, but without a lot of success. Things could be different now.

I believe truffle ruby does this: http://chrisseaton.com/truffleruby/deoptimizing/

> I think MoarVM/NQP are strikingly similar in their approach Does MoarVM use a meta-compilation technique? Pypy for example uses meta-tracing and Truffle uses Partial Evaluation to get from an interpreter specification to dynamically compiled code without duplicating the language logic. If yes, could you please point me to further information? Meta-compilation is the primary innovation in Truffle. It allows to compose languages together and to compile them as one unit. If you want to know more about the Truffle approach to meta-compilation see this PLDI paper from 2017[1]. [1] http://chrisseaton.com/rubytruffle/pldi17-truffle/pldi17-truffle.pdf

Previous Graal show offs had Ruby running C extensions by implementing a Graal JIT for x86. I imagine LLVM a nicer level of abstraction to intercept at This seems to imply only implementing a C JIT, so my memory may be wrong: http://chrisseaton.com/rubytruffle/cext Truffleruby seems to be using Sulong now: https://github.com/oracle/truffleruby/commit/f16a52934437a968bf2d2320e…

The future of this approach is Java 9 Truffle + Graal language compiler. Already a substantial amount of work has gone into making Ruby, R, node and Python to work. This is the Python implementation - https://github.com/securesystemslab/zippy http://chrisseaton.com/rubytruffle/jokerconf17/