# blog

Vanessa McHale's blog (1)
• ## Infelicities With Traditional Compiler Architecture on X86

Compilers are written as a pipeline: in particular, instruction selection and register allocation are different phases. GHC, for instance, uses maximal munch for instruction selection and a variety of register allocators. However, on x86-64 (for instance), register allocation constrains the particular instruction encodings, which affects the cost of some instructions.

• ## Calling System Functions in a JIT

Writing a practical JIT is somewhat complicated and in fact depends on the assembler; here I present a full example in Haskell. Notably this JIT/assembler is capable of calling procedures in system libraries (i.e. malloc, free)

• ## Row Types in Haskell

"Typing Haskell in Haskell" makes the implementation of type systems concrete for programmers; recent developments in type theory have much to offer but are not developed to this depth even in theory. Row types are particularly juicy because one does not lose type inference; we can use the exact same unification approach and need not resort to ordered contexts or focalization.

• ## Typing APL: Elliptic Fourier Series As an Example

Elliptic Fourier series are a good example to kick the tires on array programming systems; J and Python, however, are both dynamically typed.

• ## The Moral Imperative to Type Imperative Languages With Linear Logic

"Linear Types can change the world." Lafont has shown us how to create a linear abstract machine. Yet the moral imperative to use linear types in computer science is not widely appreciated.