7 edited body
source | link

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now, of course, it is possible to write a self-hosting interpreter, that's. That's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well, it can't be nothing, of course, so you're forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now, of course, it is possible to write a self-hosting interpreter, that's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well, it can't be nothing, of course, so you're forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now, of course, it is possible to write a self-hosting interpreter. That's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well, it can't be nothing, of course, so you're forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

6 grammar changes and correct spelling
source | link

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now, of course, it is possible to write a self-hosting interpreter, that's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well, it can't be anythingnothing, of course, so you're forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now, of course, it is possible to write a self-hosting interpreter, that's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well, it can't be anything, of course, so you're forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now, of course, it is possible to write a self-hosting interpreter, that's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well, it can't be nothing, of course, so you're forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

5 grammar changes and correct spelling
source | link

Is it possible to create a "bootstrapped" interpreter independent of the orginaloriginal interpreter?

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now, of course, it is possible to write a self-hosting interpreter, that's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well, it can't be nothinganything, of course, so youryou're forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

Is it possible to create a "bootstrapped" interpreter independent of the orginal interpreter?

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now of course, it is possible to write a self-hosting interpreter, that's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well it can't be nothing of course, so your forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

Is it possible to create a "bootstrapped" interpreter independent of the original interpreter?

According to Wikipedia, the term "bootstrapping" in the context of writing compilers means this:

In computer science, bootstrapping is the process of writing a compiler (or assembler) in the source programming language that it intends to compile. Applying this technique leads to a self-hosting compiler.

And I can understand how that would work. However, the story seems to be a little different for interpreters. Now, of course, it is possible to write a self-hosting interpreter, that's not what I'm asking. What I'm actually asking is: Is it possible to make a self-hosted interpreter independent of the original, first interpreter. To explain what I mean, consider this example:

You write your first interpreter version in language X, and the interpreter is for a new language you're creating, called Y. You first use language X's compiler to create an executable. You now can interpret files written in your new language Y using the interpreter written in language X.

Now, as far as I understand, to be able to "bootstrap" the interpreter you wrote in language X, you'd need to rewrite the interpreter in language Y. But here is the catch: even if you do rewrite the entire interpreter in language Y, you're still going to need the original interpreter you wrote in language X. Because to run the interpreter in language Y, you're going to have to interpret the source files. But what exactly is going to interpret the source files? Well, it can't be anything, of course, so you're forced to still use the first interpreter.

No matter how many new interpreters you write in language Y, you're always going to have to use the first interpreter written in X to interpret the subsequent interpreters. This seems to be a problem simply because of the nature of interpreters.

However, on the flip side, This Wikipedia article on interpreters actually talks about self-hosting interpreters. Here is a small excerpt which is relevant:

A self-interpreter is a programming language interpreter written in a programming language which can interpret itself; an example is a BASIC interpreter written in BASIC. Self-interpreters are related to self-hosting compilers.

If no compiler exists for the language to be interpreted, creating a self-interpreter requires the implementation of the language in a host language (which may be another programming language or assembler). By having a first interpreter such as this, the system is bootstrapped and new versions of the interpreter can be developed in the language itself

It's still not clear to me though, how exactly this would be done. It seems that no matter what, you're always going to be forced to use the first version of your interpreter written in the host language.

Now the article mentioned above links to another article in which Wikipedia gives some examples of supposed self-hosting interpreters. Upon closer inspection though, it seems that the main "interpreting" part of many of those self-hosting interpreters (especially some of the more common ones such as PyPy or Rubinius) are actually written in other languages such as C++ or C.

So is what I describe above possible? Can a self-hosted interpreter be independent of its original host? If so, how exactly would this be done?

    Tweeted twitter.com/StackSoftEng/status/860966041605853185
4 added 200 characters in body
source | link
3 added 2 characters in body
source | link
2 Fix some grammar and spelling mistakes, clean up irrelevant tags.
source | link
1
source | link