Engineers and QA are sometimes at odds with each other. In this episode I had a chance to catch up with JP Fairfield about the frustrations QA can encounter when engineers finish some code, only to then throw it over the fence at QA to test. This behavior is counter-productive and often leads to tensions between QA and engineers. We discuss how to change this paradigm and what the engineer/QA relationship should look like.

In this episode we discussed with Shelby and Katie how best to effect change across an organization, especially when the goal is to introduce functional programming. We had a chance to learn from Shelby and Katie how they brought functional Kotlin to Intuit, and effective methods to level up on FP principles. We also had an interesting discussion around whiteboards and the interview process, and had the chance to hear their thoughts on microservices.

A chat with Michael Snoyman, VP of Engineering at FP Complete, author, speaker and creator of multiple open source libraries including Yesod and Haskell Stack. We were very curious to hear about FP Complete's recent foray into Rust. We talked about Haskell, monads, why a Haskell programmer might want to consider Rust, “bullet-point programming” and “smart compilers”.

In this episode, we discuss Agile with Agile Coach Corinne Maloof and clear up some common misconceptions. Also joining us is special guest Brittney Braxton, software engineer at Duo Security.

This episode is an initial introduction to lexers and parsers. We'll talk about creating a parser using Antlr with the Kotlin grammar spec.

We’re making a new video series on compilers where we’re creating a new Kotlin compiler with better plugin and multiplatform support as well as better compile and run-time metaprogramming features. This new compiler is called MAKI. If you want to check it out and/or contribute to it, see https://mattmoore.io/maki-compiler to get started. https://lambda.show/episodes/new-compiler-series

In this episode, we had a fun chat with ShopRunner’s principal engineer Stephen Samuel aka “Sam Sam” about the state of functional programming in the Scala, Kotlin and Haskell. We also got a chance to discuss Arrow, 47 Degrees’ open-source functional library for Kotlin.

For more episodes from the Lambda Show, please visit https://lambda.show

Arrow has multiple libraries available for functional programming. In this talk we focus on Arrow FX and learn how to handle IO in a functional way with an introduction to monadic composition. Then we examine how to compose monads in a cleaner fashion with Arrow FX's monad comprehensions. Finally, we take a look at how to parallelize IO monads with parallel map strategies.

Matt MooreSenior software engineer at Rally

For more episodes from the Lambda Show, please visit https://lambda.show

In this talk, Attila Domokos introduces us to Arrow Core and monads.

Your Kotlin app grabs data from an API, transforms it and saves the processed data in a database. However, there are so many things that could go wrong at runtime: the API might be inaccessible, the data is not what you expected or the data can't be persisted in the database. You can start adding `try` `catch` blocks to your function in your objects, but there is a better way to do it: treat your impure functions as computations with context, pass them around just like other values, and make the necessary unsafe invocation from a single point of your app, your main function.

This talk will walk you through the core functional concepts of Arrow, you will learn how `Some`, `Either` and even `IO` are functor, applicative and monad. You can use the code example from this talk as a starting point for your Arrow-learning, to write safer, simpler and more elegant functional code in Kotlin.

Attila DomokosStaff engineer at SpotHero