CoC - https://rubinius.com/code-of-conduct/ | Install - https://rubinius.com/install/
rather, String will have a constructor that takes a ByteBuffer
looking at how to introduce attributes to classes
of course, the Ruby-ish way would be a class method, something like:
class A
# Option 1: this permits various options for a specific attribute
attributes immutable: true, concurrent: true
# Option 2: this presumes all attributes are boolean
attributes :immutable, :concurrent
# Option 3: mix 1 & 2
attributes :immutable, concurrent: [:read, :write]
end
but I was thinking about something slightly different, like this:
# the 'method' scoping A would be a compiler pragma
class attributes(:immutable, :concurrent)::A
end
# this works with arbitrary class paths by inserting before the class or module being created
class A::B::attributes(:immutable)::C
end
this would allow "accumulating" attributes as classes are re-opened, but would not be able to unset attributes (eg immutable) that disallow it
it would be an interesting way to, for example, re-open Array in your program and add concurrent attribute
either syntax could allow this actually, but the 2nd form allows the compiler to know this before any code executes in the class/module body, which probably has advantages
also, this would avoid any name clashes because the
attribute identifier wouldn't be in any identifier scope (eg variable, method)
hmm, I could use the same mechanism to create a way to make data types, but the syntax would be a little weird:
class type()::V
x: int
y: int
fun norm()
sqrt(x**2 + y**2)
end
end
Like @chuckremes I like the idea of a String possibly becoming mutable (btw I don't know if it's relevant in any way here but I think I read that in the last release of Rudt they tried to relax somehow the way variables can become mutable). There has to be some flexibility here. As for the syntax I personally far prefer the use of
attributes which btw is ablso amenable to other evolution like static type declaration without having to change the syntax of Ruby. Like in attr_type my_attr: :String, my_other_attr: :Circle. This is what I opted for in Rlang.
also, not sure if you saw my examples for types in the README, but thoughts on that?
leaning more towards compiler pragmas, but I haven't implemented anything yet
Ruby doesn't have syntax for decorators but the path "method"-like syntax would function something like a decorator
what I really need to do is finish the PEG instructions and get started on a new parser
couple great videos, one very old, one brand new...
@brixen you are right: those statements are position depedent. I agree that this is quite unusual in Ruby but it is already the case for statements such as public and private that are also position dependent. One of the other advantage of this approach is that you can easily make it backward compatible by defining module methods possibly fake ones doing nothing by the way and keep your code running in older non-typed version of Ruby
So everything is equivalent for those considerations
said he emailed you at brian -at- rubinius.com a while ago but hasn’t heard back
so, just checking in
@chuckremes how have you been?
wish i had time for hobby stuff… work is busier than ever and, well, i need the $$ :)
the only rina work i’ve done lately is commenting on Day’s new white papers… interesting stuff, but i’d like to code
how are you?
I'd love to read Day's new white papers, I'll have to make some time for that
spent hours today trying to get Linux installed on a ~2008 MacBook, which has 32bit EFI but 64bit core 2 duo, so it's not possible to just use a 64bit distro iso without futzing with the bootloader :( finally got a recent version of ElementaryOS installed (which is pretty nice), but either it's very unstable or is constantly hitting swap because it locks up constantly
it's pretty wild how nasty hardware like this still is, why isn't this stuff so much easier?
my rubinius version is 5.0 in ubuntu 18.04
I see. What I do these days is disassembling whether a object file or binary file(executable file) of C with objdump in ubuntu to get the assembly code. Also I want to do it in python and ruby. I almost did it with 'pyinstaller' in python, an interpreter similar to ruby. Thus I tried to do it with rubinius. Is there any way compile ruby code? In addition, How can I recognize jit compilation at runtime in rubinius? If so, where is the compiled code?
@sunwoo2 there's no JIT to machine code right now, but if you want to build version 3.19, you can play with the previous JIT. Both the previous JIT and the new one will compile a bytecode sequence to machine code, but where the previous JIT used hand coded LLVM IR, the new one will use the instruction functions directly. What's your interest in dissassembling Ruby code? Usually the source code is available, unlike with C obj files
