EzDevInfo.com

adding CONFIG_PARROT while compiling arm Linux Kernel 2.6.37

I will like to know how do the kernel builder to compile parrot modules while compiling the kernel.

I saw a config file for 2.6.32 that has the CONFIG_PARROT modules to yes. And I know where this modules files are stored on the kernel 2.6.32 source. I want a 2.6.37 kernel builder to make this parrot modules and add them to the kernel so I can use them on a VM.

Beside adding the path to the drivers source on the Makefile and setting the CONFIG_PARROT lines to the .config file of the kernel, is there something else to do?

What's the benefit of Parrot VM for end-users?

What's the benefit of the Parrot Virtual Machine for end-users (software developers)?

For example, if I could program against Perl or Python directly why would I bother programming for them under Parrot?

Ports of the Parrot VM

Is there a list of the operating systems for which the Parrot virtual machine can be built? I would rather not go through the release notes of every version to figure it out.

Does Parrot have a multi-threaded parallel garbage collector?

My question is about the garbage collector in the Parrot Virtual Machine ( http://www.parrot.org ).

Is it multi-threaded?

Parrot VM and Static Languages

Can you create a statically typed language in Parrot VM or does it have to be dynamically typed?

How does Parrot compare to other virtual machines?

Parrot is the virtual machine originally designed for Perl 6.

What technical capabilities does the Parrot VM offer that competing virtual machines such as the Java Virtual Machine (JVM)/Hotspot VM and Common Language Runtime (CLR) lack?

What exactly is Parrot?

I understand that Parrot is a virtual machine, but I feel like I'm not completely grasping the idea behind it.

As I understand, it's a virtual machine that's being made to handle multiple languages. Is this correct?

What are the advantages of using a virtual machine instead of just an interpreter?

What specifically is Parrot doing that makes it such a big deal?

LLVM, Parrot, JVM, PyPy + python

What is the problem in developing some languages, for example python for some optimized techniques with some of LLVM / Parrot.

PyPy, LLVM, Parrot are the main technologies for common platform development.
I see this like:

• PyPy - framework to build VM with build in optimized VM for python
  So it quite general solution. The process goes as listed down:
  
  1. dynamic_language_code ->
     
  2. PyPy frontend ->
  3. PyPy internal code - bytecode ->
  4. PyPy optimization ->
  5. leaving PyPy code and:
     a. PyPy backend for some VM (like jvm)
     b. som Kit to make own VM
     c. processing/running PyPy internal code
     

Am I right About this process? For python there is optimized VM? Particularly by default there is build in VM for optimized PyPy code (step 5.c) - which is for python and every language processing can stop there and be running by it?

• Parrot - much like PyPy, but without 5.a and 5.b ? Some internal improvements for dynamic processing (Parrot Magic Cookies).

Both Parrot and PyPy are designed to create a platform which create a common dynamic languages runtime, but PyPy wants more - also to create more VM.
Where is the sens of PyPy? For what we need to create more VM? Shouldn't be better to focus on one VM (like in parrot) - because there is common one code level - either PyPy internal bytecode or Parrot ones. I think we can't gain nothing better to translate to PyPy bytecode to newly created with PyPy VMs.

• LLVM - i see this very similar to PyPy but without VM generator.
  It is mature, well designed environment with similar targets as PyPy (but without VM generator) but working on low level structure and great optimization/JIT techniques implemeted

Is see this as: LLVM is general use, but Parrot and *PyPy designed for dynamic languages. In PyPy / Parrot is more easy to introduce some complicated techniques - because it is more high level then LLVM - like sophisticate compiler which can better understand high level code and produce better assembler code (which humans can't write in reasonable time), then the LLVM one?

Questions:

1. Am I right? Is there any reason that porting some dynamic language would be better to llvm then to for example Parrot?

2. I haven't see the activity on development python on Parrot. Is it because using python C extensions doesn't work on parrot? The same problem is in PyPy

3. Why other VMs don't want to move to LLVM / parrot. Eg ruby -> parrot, CLR/ JVM -> LLVM. Wouldn't be better for them to move to more sophisticated solution? LLVM is in high development process and has big companies investing in.

4. I know the problem might be in recompile are resources, if there is need to change bytecode - but it is not obligatory - as we can try to port old bytecode to new one, and new compilers produce new bytecode (never less java still need to interpreted own bytecode - so the frontend can check it and translate it to new bytecode)?

5. What are the problems with linking for example jvm libraries inside llvm (if we port somehow java/jvm/scala to llvm)?

6. Can you correct me if i'm wrong somewhere

Some addings:

• How does Parrot compare to other virtual machines
• What's the benefit of Parrot VM for end-users
• What are the differences between LLVM and java/jvm

=============

CLARIFICATION

I want to figure how all this software consist - and what is the problem to porting one to other.

How do I get started with Perl 6?

I'd like to get your opinion on How to get started with Perl 6? Shall one use Rakudo which is being build on Parrot or still better go with the Pugs implementation?

If Rakudo, what is the best way to install it? The monthly releases of Parrot, right from the SVN of Parrot, other?

Why to use Parrot (or other VM) if I have an interpreter?

Why should I use VM, like Parrot, for a dynamic language I use (Python, Perl, ...) if I already have an interpreter? What can I potentially gain, for the cost of having different VM between my code and my machine, and by using a separate interpreter?

(I am new in VM issue, so maybe the answer is obvious)

EDIT

What's the benefit of Parrot VM for end-users?

Do VMs like LLVM or PARROT allow usage of the same library from multiple languages?

Is it possible to use one framework written in one Parrot (LLVM) language in any other Parrot (LLVM) language? (Like usage of .NET Framework from any CLR language)...

What is the release date for Rakudo Star (perl6)? [closed]

If a specific release date is not available (as I suspect it is not), can you provide resources for tracking how close it is to the desired feature set that allows release.

I'm not necessarily asking for a percentage gauge, or X of Y features completed list. A list of bugs marked in whichever section of the perl RT instance that's tracking Rakudo bugs would meet my criteria, even more so if the list is dynamic (I.e. it's a list of bugs tagged in some manner, not a static list of ticket numbers). If there are only a few planned features left to be finished/tested before it's considered ready for final testing, listing those would also be sufficient.

What is a good VM for developing a hobby language?

I'm thinking about writing my own little language.

I found a few options, but feel free to suggest more.

• JVM
• Parrot
• OSA

A lot of languages are using the JVM, but unless you write a Java-ish language, all the power the stdlib gives you is going to feel ugly; It's not very good at dynamic stuff either.

Parrot seems a good VM for developing languages, but it has a little abandoned/unfinished/hobby project smell to it.

OSA is what powers Applescript, not a particularly well known VM, but I use Mac, and it offers good system integration.

CLR+Mac doesn't seem a good combination...

My language is going to be an object orientated functional concurrent dataflow language with strong typing and a mix of Python and Lisp syntax. Sounds good, eh?

[edit]
I accepted Python for now, but I'd like to hear more about OSA and Parrot.

Is Ruby or other language going to run faster on Parrot?

I just saw that there is a Ruby to Parrot compiler called Cardinal, which can create code to run on Parrot, which is a VM that can run byte-code. How is the performance of Ruby or any language compile to it and run there because for example, Ruby probably doesn't have pre-compiled byte code. Can it be faster running on Parrot? Python probably will be better off running as it is because it has .pyc.

Parrot - Can I use it? And how?

I've had an eye on Parrot for a little while. I understand that it's a virtual machine designed to run a variety of dynamic languages, and to allow a degree of interoperability (e.g. calling a Perl function from a Python script). So, my question is in two parts:

1. Is Parrot ready for general use? I can see releases are being made, but it's not obvious whether it's something that works well now, or still a work in progress.
2. Is there any documentation on how to use Parrot? I've looked at links in previous questions, but all the documentation I can find talks about the various levels of Parrot-specific code (PIR, PASM, etc.), or how to add support for more languages. That's great, but how do I run code in existing languages on Parrot? And how do I use code written in another language?

Finally, I don't want to start a flamewar, but I know Parrot is tied up with Perl 6. I prefer Python. I understand Python is a supported language, but realistically, is it perceived as a multi-language VM, or is it a Perl 6 interpreter with other languages included as curiosities?