Though I haven’t taken that much time to learn about type systems, I have read up a little bit. I devoured Chris Smith’s essay on What To Know Before Debating Type Systems and briefly tinkered around with a typed lambda calculus before trying to really get into some of the heavier stuff that my program covered in a seminar earlier this year. All of this, combined with my personal experiences using dynamically and statically typed languages, gave me just enough of a background to get by when learning or comparing various programming languages. While I favor dynamically-typed languages (like Lisp), Ruby) and Python)) as a matter of personal preference, I have tremendous respect for statically-typed languages (like C) and Java)). In my humble opinion, some of the most interesting languages are those which allow one to switch between the paradigms as need or desire dictates. Take for example, Haskell)’s type annotations or Common Lisp’s type specifiers (particularly declare). The former allows one to annotate Haskell function definitions with type information to enforce type constraints while the latter can be used to turn off Lisp’s dynamic typing system when trying to do something special like optimize certain functions. After I discovered all of this and determined that I think it’s pretty neat but not something I have the time to pursue right now, my interest has been rekindled by a recently delivered presentation entitled Types Considered Harmful. Perhaps it’s also time for me to re-read another famous type-system paper, Java is not type-safe.