Stephanie Weirich's guest appearances

Stephanie Weirich

The Type Theory Podcast

CoRecursive: Coding Stories

Edwin Brady

Cory Doctorow

Sam Ritchie

David Heinemeier Hansson

Steven Proctor

Daniel Lemire

Andy Hunt

Jonathan Boccara

Lee Edwards

Jamis Buck

Gabriel Gonzalez

Sean Allen

Thorsten Ball

Zach Tellman

Justin Woo

OwlTail

Tech Talks are in-depth technical discussions. At Strange loop 2017, a wandered into a talk where I saw some code that deeply surprised me. The code could have been python if you squinted, passing dictionaries around, no type annotations anywhere. Yet key look up in the dictionary was validated at compile time. It was a compile time error to access elements that didn't exist. Also the dictionary was heterogeneous, the elements had different types, and it was all inferred and validated at compile time.  What I was seeing was Dependent types in Haskell. In today's interview Stephanie Weirich explains her efforts to add dependent types to haskell and how that example worked.   Shows Notes:  Dependent Types in Haskell Talk https://www.cis.upenn.edu/~sweirich/ https://github.com/sweirich @fancytypes Dependent Types Regex 

Tech Talks are in-depth technical discussions. At Strange loop 2017, a wandered into a talk where I saw some code that deeply surprised me. The code could have been python if you squinted, passing dictionaries around, no type annotations anywhere. Yet key look up in the dictionary was validated at compile time. It was a compile time error to access elements that didn't exist. Also the dictionary was heterogeneous, the elements had different types, and it was all inferred and validated at compile time. What I was seeing was Dependent types in Haskell. In today's interview Stephanie Weirich explains her efforts to add dependent types to haskell and how that example worked. Shows Notes: <ul> <li><a href="https://thestrangeloop.com/2017/dependent-types-in-haskell.html" rel="noopener nofollow" target="_blank">Dependent Types in Haskell Talk</a></li> <li><a href="https://www.cis.upenn.edu/~sweirich/" rel="nofollow" target="_blank">https://www.cis.upenn.edu/~sweirich/</a></li> <li><a href="https://www.youtube.com/watch?v=wNa3MMbhwS4" rel="noopener nofollow" target="_blank">https://github.com/sweirich</a></li> <li><a href="http://twitter.com/fancytypes" rel="nofollow" target="_blank">@fancytypes</a></li> <li><a href="https://github.com/sweirich/dth/tree/master/regexp" rel="noopener nofollow" target="_blank">Dependent Types Regex</a></li> </ul>

Tech Talk: Dependent Types in Haskell with Stephanie Weirich

In our fourth episode, we speak with Stephanie Weirich from the University of Pennsylvania on the Zombie language and Dependent Haskell. Stephanie is a long-time contributor to Haskell, having been involved in the design and implementation of features such as generalized algebraic datatypes, higher-rank polymorphism, type families, and promoted datatypes. She has also been a participant in Trellys, a project with the goal of combining proofs and programming in the same language.Zombie is a different kind of dependently typed language, eschewing automatic β-reduction in the type checker for an approach based on explicit equality rewriting, which enables new ways of combining proofs and programs, as well as new forms of proof automation. Meanwhile, as languages designed for dependently typed programming come closer to practical applicability, Haskell is also moving towards full dependent types. We discuss the challenges and opportunities available at the cutting edge of Haskell.

In our fourth episode, we speak with Stephanie Weirich from the University of Pennsylvania on the Zombie language and Dependent Haskell. Stephanie is a long-time contributor to Haskell, having been involved in the design and implementation of features such as generalized algebraic datatypes, higher-rank polymorphism, type families, and promoted datatypes. She has also been a participant in Trellys, a project with the goal of combining proofs and programming in the same language. Zombie is a different kind of dependently typed language, eschewing automatic β-reduction in the type checker for an approach based on explicit equality rewriting, which enables new ways of combining proofs and programs, as well as new forms of proof automation. Meanwhile, as languages designed for dependently typed programming come closer to practical applicability, Haskell is also moving towards full dependent types. We discuss the challenges and opportunities available at the cutting edge of Haskell.

Episode 4: Stephanie Weirich on Zombie and Dependent Haskell