Hi! Interested in GSoC. Feedback on these ideas?

[Paul Raccuglia]

Hi! I'm interested in working on guile as part of the Google Summer of Code.

I'm Paul Raccuglia, a Math/CS student at Haverford College (and
general freelance hacker). I'm pretty excited by Guile, I think it's a
cool project. I do a lot of Python coding, and I love interpreted
languages; Guile seems like a great way to combine the comfort of
interpreted languages with the general badassery of C.

 I've been talking with a friend who contributes to this project, and
we came up with some exciting ideas for working on Guile over the
summer.

Currently I am thinking about:

- A package manager (in the vein of apt-get)
I know this is one that's come up a bit. I was thinking of writing a
small web interface to browse packages, an aptitude style command-line
method for downloading, verifying the hashes, checking dependencies,
and then install the package(s) and an uninstall function as well. I
saw the proposal of working with dorodango; I might look at it, but
from what I saw of the code base, I thought it would make sense to try
to write a GUILE specific package-manager.


- AOT Compiler: write an interface to GCC
I think this would be really cool. A good plan would be to use GCC,
because it's already pretty sophisticated and handles lots of
architectures. I would start by writing a scheme interface to GCC, and
then writing the compiler in scheme.

I noticed a relevant (but now dead) project to write a GCC scheme
compiler : http://gna.org/projects/gsc  ; they started in '05 and died
by '06, but I think it would help me think through the process to look
at what other people did.


- JIT compiler
I talked with Noah Lavine about this (he's the person who directed me
to Guile in the first place), and I think this is a really exciting
project. My first step would be to clean up the code that he has
written, and then build on that to make it fully functional. Big
issues raised are smoothly integrating this with Guile, and
implementing all of the VM instructions without duplicating ridiculous
quantities of code. A suggestion (of Noah's) was to work on
integrating the JIT with Guile and then adding the VM instructions to
the JIT.


Could y'all give me some guidance on this? I'd really appreciate it.

-- Paul Raccuglia
address@hidden