Ruby vs Python vs Java bytecode concept

ruby-talk
1

Hi,

I have a confusion about the process of ruby file.

Suppose you have a file named f.rb.
To run this file you do:
ruby f.rb

After this command what does happen?

I knew for python, python makes bytecode and java makes .class. Both are
not human readable.

Is ruby a interpreted language or compiled language?

Can anyone please exaplain/elaborate with example about the processing
or running a ruby file?

Thanks.

···

--
Posted via http://www.ruby-forum.com/.

2

Ruby (1.9+) internally creates bytecode that is slightly similar to
Python's one, but it doesn't save it anywhere (it is regenerated every
time the script is run). Ruby 1.8 just directly evaluated the source
code, without creating bytecode form.

-- Matma Rex

3

Maybe it depends on the the system that you use to run ruby. For
example, YARV (now ruby 1.9) is a bytecode interpreter. I suppose that
ruby code is converted to a bytecode sintactical tree that is
interpreted by YARV. This is different to compile C, because the
output of GCC is a machine code and not a sintactical tree.

···

At Wed, 20 Jun 2012 23:56:48 +0900, gmspro gmspro wrote:

Hi,

I have a confusion about the process of ruby file.

Suppose you have a file named f.rb.
To run this file you do:
ruby f.rb

After this command what does happen?

I knew for python, python makes bytecode and java makes .class. Both are
not human readable.

Is ruby a interpreted language or compiled language?

--
Daniel

4

Daniel Hernandez писал 20.06.2012 20:03:

Hi,

I have a confusion about the process of ruby file.

Suppose you have a file named f.rb.
To run this file you do:
ruby f.rb

After this command what does happen?

I knew for python, python makes bytecode and java makes .class. Both are
not human readable.

Is ruby a interpreted language or compiled language?

Maybe it depends on the the system that you use to run ruby. For
example, YARV (now ruby 1.9) is a bytecode interpreter. I suppose that
ruby code is converted to a bytecode sintactical tree that is
interpreted by YARV. This is different to compile C, because the
output of GCC is a machine code and not a sintactical tree.

Bytecode has nothing to do with syntactical trees. Abstract syntax tree
is a notation used to represent the _source code_, e.g.

require 'ripper'; require 'pp'
pp Ripper.sexp("puts 1 + 2")

[:program,
  [[:command,
    [:@ident, "puts", [1, 0]],
    [:args_add_block,
     [[:binary, [:@int, "1", [1, 5]], :+, [:@int, "2", [1, 9]]]],
     false]]]]

The mentioned structure can be thought of as a tree because it does not
have any loops (if you can't imagine it, try to find inspiration in this
image: http://cs.lmu.edu/~ray/images/gcdast1.png\)

Bytecode is a format used akin to machine code, but for a virtual machine
specialized for a certain language. Nothing (except maybe common sense)
prevents you from creating a very real, silicon processor for the YARV
bytecode; it isn't inherently inferior to x86 machine code. Bytecode
looks like this:

puts RubyVM::InstructionSequence.new("puts 1 + 2").disasm

== disasm: <RubyVM::InstructionSequence:<compiled>@<compiled>>==========
0000 trace 1 ( 1)
0002 putself
0003 putobject 1
0005 putobject 2
0007 opt_plus <ic:2>
0009 send :puts, 1, nil, 8, <ic:1>
0015 leave

As you can see, it's very similar to assembler code, but of a kind
developed specially for Ruby.

Ruby 1.8 walks each node of the AST and interprets them. This is very slow.
Ruby 1.9 first converts the AST to the bytecode and then executes the bytecode.
This still isn't very fast, but at least it is much faster than walking the AST.

···

At Wed, 20 Jun 2012 23:56:48 +0900, > gmspro gmspro wrote:

--
Daniel

--
   WBR, Peter Zotov.

5

Thanks! you help me to understant the difference!

-- Daniel

···

At Thu, 21 Jun 2012 10:46:05 +0900, Peter Zotov wrote:

Daniel Hernandez писал 20.06.2012 20:03:
> At Wed, 20 Jun 2012 23:56:48 +0900, > > gmspro gmspro wrote:
>>
>> Hi,
>>
>> I have a confusion about the process of ruby file.
>>
>> Suppose you have a file named f.rb.
>> To run this file you do:
>> ruby f.rb
>>
>> After this command what does happen?
>>
>> I knew for python, python makes bytecode and java makes .class. Both
>> are
>> not human readable.
>>
>> Is ruby a interpreted language or compiled language?
>
> Maybe it depends on the the system that you use to run ruby. For
> example, YARV (now ruby 1.9) is a bytecode interpreter. I suppose
> that
> ruby code is converted to a bytecode sintactical tree that is
> interpreted by YARV. This is different to compile C, because the
> output of GCC is a machine code and not a sintactical tree.

Bytecode has nothing to do with syntactical trees. Abstract syntax tree
is a notation used to represent the _source code_, e.g.

> require 'ripper'; require 'pp'
> pp Ripper.sexp("puts 1 + 2")
[:program,
  [[:command,
    [:@ident, "puts", [1, 0]],
    [:args_add_block,
     [[:binary, [:@int, "1", [1, 5]], :+, [:@int, "2", [1, 9]]]],
     false]]]]

The mentioned structure can be thought of as a tree because it does not
have any loops (if you can't imagine it, try to find inspiration in
this
image: http://cs.lmu.edu/~ray/images/gcdast1.png\)

Bytecode is a format used akin to machine code, but for a virtual
machine
specialized for a certain language. Nothing (except maybe common sense)
prevents you from creating a very real, silicon processor for the YARV
bytecode; it isn't inherently inferior to x86 machine code. Bytecode
looks like this:

> puts RubyVM::InstructionSequence.new("puts 1 + 2").disasm
== disasm:
<RubyVM::InstructionSequence:<compiled>@<compiled>>==========
0000 trace 1 (
  1)
0002 putself
0003 putobject 1
0005 putobject 2
0007 opt_plus <ic:2>
0009 send :puts, 1, nil, 8, <ic:1>
0015 leave

As you can see, it's very similar to assembler code, but of a kind
developed specially for Ruby.

Ruby 1.8 walks each node of the AST and interprets them. This is very
slow.
Ruby 1.9 first converts the AST to the bytecode and then executes the
bytecode.
This still isn't very fast, but at least it is much faster than walking
the AST.

6

Holy crap, I didn't even know about RubyVM.

Is there a way to get at the code from a block passed in? Looking at the
docs, it appears both of these take a string, Could I do this sort of
analysis and manipulation on ASTs or would I need to drop into C for that?

···

On Wed, Jun 20, 2012 at 8:46 PM, Peter Zotov <whitequark@whitequark.org>wrote:

Daniel Hernandez писал 20.06.2012 20:03:

At Wed, 20 Jun 2012 23:56:48 +0900, >> gmspro gmspro wrote:

Hi,

I have a confusion about the process of ruby file.

Suppose you have a file named f.rb.
To run this file you do:
ruby f.rb

After this command what does happen?

I knew for python, python makes bytecode and java makes .class. Both are
not human readable.

Is ruby a interpreted language or compiled language?

Maybe it depends on the the system that you use to run ruby. For
example, YARV (now ruby 1.9) is a bytecode interpreter. I suppose that
ruby code is converted to a bytecode sintactical tree that is
interpreted by YARV. This is different to compile C, because the
output of GCC is a machine code and not a sintactical tree.

Bytecode has nothing to do with syntactical trees. Abstract syntax tree
is a notation used to represent the _source code_, e.g.

> require 'ripper'; require 'pp'
> pp Ripper.sexp("puts 1 + 2")
[:program,
[[:command,
  [:@ident, "puts", [1, 0]],
  [:args_add_block,
   [[:binary, [:@int, "1", [1, 5]], :+, [:@int, "2", [1, 9]]]],
   false]]]]

The mentioned structure can be thought of as a tree because it does not
have any loops (if you can't imagine it, try to find inspiration in this
image: http://cs.lmu.edu/~ray/images/**gcdast1.png&lt;http://cs.lmu.edu/~ray/images/gcdast1.png&gt;
)

Bytecode is a format used akin to machine code, but for a virtual machine
specialized for a certain language. Nothing (except maybe common sense)
prevents you from creating a very real, silicon processor for the YARV
bytecode; it isn't inherently inferior to x86 machine code. Bytecode
looks like this:

puts RubyVM::InstructionSequence.**new("puts 1 + 2").disasm

== disasm: <RubyVM::InstructionSequence:<**compiled>@<compiled>>=========*
*=
0000 trace 1 ( 1)
0002 putself
0003 putobject 1
0005 putobject 2
0007 opt_plus <ic:2>
0009 send :puts, 1, nil, 8, <ic:1>
0015 leave

As you can see, it's very similar to assembler code, but of a kind
developed specially for Ruby.

Ruby 1.8 walks each node of the AST and interprets them. This is very slow.
Ruby 1.9 first converts the AST to the bytecode and then executes the
bytecode.
This still isn't very fast, but at least it is much faster than walking
the AST.

--
Daniel

--
WBR, Peter Zotov.

7

Unfortunately the asts are dumped after compile

···

On Jun 21, 2012, at 19:39, Josh Cheek <josh.cheek@gmail.com> wrote:

Is there a way to get at the code from a block passed in? Looking at the docs, it appears both of these take a string, Could I do this sort of analysis and manipulation on ASTs or would I need to drop into C for that?

8

rubiunius

···

On 22/06/12 12:50, Ryan Davis wrote:

Unfortunately the asts are dumped after compile

On Jun 21, 2012, at 19:39, Josh Cheek <josh.cheek@gmail.com> wrote:

Is there a way to get at the code from a block passed in? Looking at the docs, it appears both of these take a string, Could I do this sort of analysis and manipulation on ASTs or would I need to drop into C for that?