I'm interested in learning how to create a compiler for a dynamically typed language. Most compiler books, college courses and articles/tutorials I've come across are specifically for statically typed languages. I've thought of a few ways to do it, but I'd like to know how it's usually done. I know type inferencing is a pretty common strategy, but what about others?

Where can I find out more about how to create a dynamically typed language?

Edit 1:
I meant dynamically typed. Sorry about the confusion.

I've written toy compilers for statically typed languages and written some interpreters for dynamically typed languages. Now, I'm interested in learning more about creating compilers for a dynamically typed language. I'm specifically experimenting with LLVM and since I need to specify the type of every method and argument, I'm thinking of ways to implement a dynamically typed language on something like LLVM.

This question appears to be off-topic. The users who voted to close gave this specific reason:

"Questions asking us to recommend a tool, library or favorite off-site resource are off-topic for Programmers as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it." – gnat, MichaelT, GlenH7, jmo21, Michael Kohne

Dynamic compilers are almost exclusively only used in emulators as dynamic recompilers. This wouldn't happen to be your intention for researching the subject area, would it? And speaking of this, examining the source code to said emulators is probably your best bet for learning about dynamic compilers.
–
Rob S.Mar 10 '11 at 2:44

@Rob S, I'm thinking more along the lines of something like a scheme or common lisp compiler. I know most popular dynamic languages are interpreted, but I was thinking there have to be some compilers as well.
–
TriArcMar 10 '11 at 3:29

llvm is not different from any native target. You must have some form of runtime type information, you'd need an efficient implementation of a dynamic dispatch (e.g., for all the arithmetic operations over all of the types from Scheme numeric tower), and, if you're bold, you can use an abstract interpretation in order to specialise types wherever it is possible and explicitly get rid of a dynamic dispatch. That's it. The rest is pretty much the same as for the statically typed languages.
–
SK-logicMar 10 '11 at 15:52

I would also recommend reading the Ruby source code. I have not attempted to read it in many years. But when I last tried, it was remarkably clear and easy to understand. There are a lot of good ideas in there.

@SK-logic: Quite possibly true. The term still scares me because it leads to much confusion. Example: folks asking for the Python equivalent to a cast operator.
–
S.LottMar 10 '11 at 12:26

@S.Lott, it actually makes sense. A dynamically typed language still can be annotated (by such 'casts'), which helps to fall back to a type inference in a smart static compiler. Many Common Lisp implementations are doing this.
–
SK-logicMar 10 '11 at 12:55

@David, surprisingly, yes, it is more advanced. Simply because Javascript is a way much more dynamic than Common Lisp, and thus a compiler should be much more complicated. Common Lisp compilers are relatively trivial, and they're providing enough functionality for improving performance manually (e.g., type hints). Javascript is a completely different beast.
–
SK-logicMar 10 '11 at 16:08

If you are interested in a common lisp compiler--how it's done and so forth--you might check out the source code for Armed Bear Common Lisp and target some specific questions to that community. Mac Ruby is a compiler for Ruby that uses the LLVM infrastructure. The source code and community around either project could be valuable resources for you.