英特尔8086 DOS组件应使用什么代码骨架？(What code skeleton should I use for Intel 8086 DOS assembly?)

 在Ruby中，引用一个局部变量和一个消息发送给隐含接收者而没有参数列表之间存在歧义。 这意味着 
 
foo
 
 可以是“取消引用局部变量”或“将消息发送给没有参数的self ”，即它可以等同于 
 
binding.local_variable_get(:foo)
 
 要么 
 
self.foo()
# or
public_send(:foo)
 
 这个歧义在解析时被解决。 当解析器遇到对foo的赋值时，它将从此处将foo视为局部变量，而不管赋值是否实际执行。 （这是解析器无法静态确定的，只要想一想if rand > 0.5 then foo = 42 end 。） 
 
 
 
 在编译语言中，这甚至不会编译。 
 
 
 编译语言没有这样的东西。 编译和解释是编译器或解释器（duh！）而不是语言的特征。 语言既不编译也不解释。 他们只是。 
 
 每种语言都可以通过编译器来实现，每种语言都可以通过解释器来实现。 大多数语言都有编译和解释实现（例如，C有GCC和Clang，它们是编译器，Cint和Cling是解释器，Haskell有GHC，它是编译器，Hugs是解释器）。 
 
 许多现代语言实现都在相同的实现中，或者处于不同的阶段（例如，YARV和MRuby将Ruby源代码编译为内部字节码，然后解释该字节码），或者在混合模式引擎中（例如HotSpot JVM都解释和编译JVM字节码，取决于哪个更有意义），或者两者兼有（例如Rubinius在第一阶段将Ruby源代码编译为Rubinius字节码，然后将该字节码编译为本地代码并解释它，具体取决于更有意义的内容）。 
 
 实际上， 所有现有的Ruby实现都已编译：YARV和MRuby编译为自己的内部字节码格式，Rubinius，MacRuby，MagLev和Topaz编译为自己的内部字节码格式，然后将其编译为本地代码，JRuby编译为JVM字节码JVM可能进一步编译或不编译），IronRuby编译为CIL字节码（VES可能进一步编译或不编译）。 
 
 Ruby以这种方式行事的事实是因为语言规范说明了这一点。 并不是因为Ruby被“解释”，因为事实上并非如此。 Ruby的唯一纯粹的解释实现是MRI和JRuby的早期版本，并且两者早已退役。 

In Ruby, there is an ambiguity between referencing a local variable and a message send to the implicit receiver without an argument list. That means 
 
foo
 
can either mean "dereference a local variable" or "send message foo to self without arguments", i.e. it could either be equivalent to 
 
binding.local_variable_get(:foo)
 
or 
 
self.foo()
# or
public_send(:foo)
 
This ambiguity is resolved at parse time. When the parser encounters an assignment to foo, it will, from that point on, treat foo as a local variable, regardless of whether or not the assignment actually gets executed. (That's something the parser cannot determine statically, after all. Just think about if rand > 0.5 then foo = 42 end.)
 
 
 
In a compiled language this wouldn't even compile.
 
 
There is no such thing as a compiled language. Compilation and interpretation are traits of the compiler or interpreter (duh!) not the language. Languages are neither compiled nor interpreted. They just are.
 
Every language can be implemented with a compiler and every language can be implemented with an interpreter. Most languages have both compiled and interpreted implementations (e.g. C has GCC and Clang, which are compilers, and Cint and Cling, which are interpreters, Haskell has GHC, which is a compiler, and Hugs, which is an interpreter).
 
Many modern language implementations have both in the same implementation, either in different phases (e.g. YARV and MRuby compile Ruby sourcecode to internal bytecode, and then interpret that bytecode), or in a mixed-mode engine (e.g. the HotSpot JVM both interprets and compiles JVM bytecode, depending on which makes more sense), or both (e.g. Rubinius compiles Ruby sourcecode to Rubinius bytecode in the first phase, and then both compiles that bytecode to native code and interprets it, depending on what makes more sense).
 
In fact, all currently existing Ruby implementations are compiled: YARV and MRuby compile to their own internal bytecode formats, Rubinius, MacRuby, MagLev and Topaz compile to their own internal bytecode formats, then compile that to native code, JRuby compiles to JVM bytecode (which the JVM may or may not compile further), IronRuby compiles to CIL bytecode (which the VES may or may not compile further).
 
The fact that Ruby behaves this way is because the language specification says so. Not because Ruby is "interpreted", because, actually, it is not. The only purely interpreted implementation of Ruby was MRI and very early versions of JRuby, and both have long since been retired.