In the Flix programming language we are explore three research topics:
- Type and effect systems that support inference
Programming languages with static type systems help programmers avoid errors by ruling out entire classes of bugs at compile time. While a static type system specifies the kinds of values an expression may produce, an effect system characterizes the computational actions it may perform. In this way, effect systems extend the benefits of type systems by enabling richer forms of static program reasoning. Type-and-effect systems that support inference achieve this without imposing additional annotation requirements on the programmer; instead, the compiler automatically determines the types and effects of every expression. - Embedded logic programming
Logic programming is a powerful paradigm for addressing certain classes of computational problems. However, its languages have yet to see widespread adoption, largely due to challenges in handling the more routine aspects of programming. By embedding logic programming within general-purpose languages, we can combine the strengths of both approaches and gain the best of both worlds. - Modern compiler design
Modern compilers are no longer simple batch processors that operate on one file at a time. Instead, they are expected to power IDE services such as semantic syntax highlighting, intelligent autocomplete, and automated refactoring, in addition to their traditional role of ensuring that programs are well-formed; that is, semantically and type correct. These demands impose new constraints on compiler design: compilers must now be fast, incremental, parallel, and resilient.
Programming languages are the foundational tools used to create software. Better programming languages empower developers by making software faster, safer, and the development experience more ergonomic. At the core of programming languages are type and effect systems, which support reasoning about programs and help ensure essential safety properties. These systems also enable the construction of powerful abstractions - an essential capability for scaling software development and addressing complex challenges effectively.
