Functional Geekery: Recent Episodes
Proctor
In this episode, I talk with Shriram Krishnamurthi. We cover his introduction to functional programming, Racket and #lang, Static vs Dynamic Typing, Bootstrap and Pyret, How to Design Programs, and much, much, more.
In this episode I talk with Katja Mordaunt and Adam Warski. We talk Katja's and Adam's introduction to software, being on the LambdaDays 2022 Programme Committee, a peek what being on the Programme Committee looks like, introducing new people to functional programming, and more.
In this episode I talk with Laura M. Castro. We talk her introduction to Erlang, Final Project and Ph.D. around Erlang, Research and Teaching using Erlang and Elixir, the Erlang Ecosystem Foundation, Code Beam Lite, Erlang Workshops and more.
In this episode I talk with Aleksander Lisiecki. We talk his introduction to Erlang, non-standard use cases for Erlang and Elixir, Erlang and Elixir School, and more.
In this episode I talk with Renzo Borgatti. We talk his introduction to Clojure, learning the extended vocabulary of Clojure, his book Clojure: The Essential Reference, gems in the Clojure language, side projects, and much more.
In this episode I talk with Yehonathan Sharvit. We talk his upcoming book Data Oriented Programming, what Data Oriented Programming is, how it differs from Functional Programming, how DOP fits with typed languages, and more.
s episode I talk with Jordan Miller. We talk her breaking into to software development, activity in the Clojure community, redefining open source contributions, mentoring, and much more.
In this episode I talk with Claude Rubinson. We talk his experience learning and using functional programming as a sociologist, organizing software user groups, and more.
In this episode I talk with James Stelly. We talk his explorations of programming languages and how that led to his book Racket Programming the Fun Way.
In this episode I talk with Duncan McGreggor. We talk his introduction to functional programming; Erlang; Lisp Flavoured Erlang; Lisps, Lisps, and more Lisps; and much, much, more.
In this episode I talk with Martin J. Logan. We talk his experience in CTO roles guiding organizations through functional programming transformations, from lessons learned, tips, tools, strategies, how the grassroots level can help, and much more.
In this episode I talk with Ivan Čukić. We talk his introduction to functional programming, adopting Scala, his book "Functional Programming in C++", the C++ communities adoption of functional programming, and much more.
In this episode I talk with Eric Normand. We talk his podcast "Thoughts on Functional Programming"; his in progress book "Grokking Simplicity"; Actions, Calculations, and Data; trying to bury mutation and side-effects; Property-Based testing; and more.
In this episode I talk with Gene Kim. We talk his introduction to Clojure and functional programming, The Phoenix Project and The Unicorn Project, Functional Architecture, lessons learned, his Love Letter to Clojure, and much, much, more.
In this episode I talk with Katie Hughes. We talk her introduction to software development, exposure to functional programming, orienting herself in a new codebase, "learning to trust again", and much more.
In this episode I talk with Andy Hunt and Dave Thomas. We talk about their upcoming 20th Anniversary Edition of The Pragmatic Programmer, what prompted a 20th Anniversary Edition, what has changed and what has stayed the same in the 20 years since, where they see things going based off what they have seen, and much, much more.
In this episode I talk with Verónica López. We talk her background, exposure to Go and Elixir, working with CoreOS and Kubernetes, being a bridge between Kubernetes and the BEAM communities, and more.
In this episode I talk with Sam Guyer and Caleb Helbling. We talk about Juniper, a functional reactive programming language for Arduino programming.
In this episode I talk with Zach Tellman. We talk his introduction to Clojure, how he has noticed Clojure change over the past 10 years, his book Elements of Clojure, and more.
In this episode I talk with Brian Troutwine. We catch up with his work in Erlang, working in Rust, applying functional programming techniques to Rust, learning Erlang compared to Rust, his book "Concurrent Rust" that is in the works, and much more.
In this episode I talk with Claudia Doppioslash. We catch up with what she has been doing since Episode 42, which includes PureScript and Elm, GRiSP, applying functional ideas to game programming, and more.
In this episode I talk with Lisa Passing. We talk her introduction to Clojure and functional programming, her intro to Rust, how Rust fits in the functional programming world, and more.
In this episode I talk with Jared Forsyth. We talk his exploration of programming languages, his exposure to programming languages, work in the Reason community, Reason Town, and more.
In this episode I talk with Scott Nimrod. We catch up with what he has been up to since he was last on, using F# for profit, Nikeza, Elm, and more.
In this episode I talk with Eric Normand. We catch up with what he has been up to since last episode, talk re-frame in ClojureScript, his newsletter, Clojure SYNC, online community discussions, and more.
In this episode I talk with Radu Popescu. We talk his introduction to software development, high performance C++, where functional ideas fit in with high performance C++, CernVM File System, Erlang, an overview of where Rust fits between functional languages and C++, and more.
In this episode I talk with Sam Williams. We talk his introduction to programming, moving to web-development with Erlang, the HydrOS project, the Archain project, and more.
In this episode I talk with Fred Herbert. We talk his introduction to Erlang, making languages accessible to the community, productionization as a phase of software, property testing, we wrap up with a tease of how "Everything is Terrible", and much more.
In this episode I talk with Oskar Wickström. We talk his introduction to software development, journey to functional programming, tooling, state machines and static typing, and more.
In this episode I talk with Micheal Sperber. We talk his introduction to programming and functional programming languages, important commonalities across languages, power of syntactic abstraction, teaching programming to beginners and experienced programmers, Concurrent ML, and more.
In this episode I talk with Stian Veum Møllersen. We talk his introduction to programming, exploring programming languages, "Perlis Languages", Concatenative Languages, Creative Programming, and more.
In this episode I talk with Kiwamu Okabe. We talk his introduction to writing software for hardware; exposure to functional programming; running Haskell, ATS, and VeriFast verification on bare metal hardware; and more.
In this episode I talk with Zach Kessin. We talk his transition to using Elm for front-end web development, using it with Erlang back-ends, his goal to help grow the community around Elm, and more.
In this episode I talk with David Christiansen. We talk his introduction to functional programming, research in dependent types, Idris, Nuprl and LFC traits, work to add dependent types to macro-expansion in Racket, and much, much more.
In this episode I talk with Julie Moronuki. We catch up about "Haskell Book", cover the upcoming Joy of Haskell, lessons learned teaching Haskell in user groups, other projects, linguistics, and more.
In this episode I talk with Reid Evans. We talk his introduction to functional programming, F#, functional JavaScript, Functional Knox, and much more.
In this episode I talk with David Koontz. We talk his introduction to functional programming, F#, Haskell, community building, the LambdaCast, and more.
In this episode I talk with Debasish Ghosh. We talk his introduction to Scala, domain modeling, lawful abstractions, extracting algebraic patterns from a code base, and more.
In this episode I talk with Justin Schneck. We talk embedded Erlang and Elixir with the Nerves Project, where Nerves fits in the landscape of embedded systems, prototyping vs deployment, and much, much more.
In this episode I talk with Brian Hicks. We talk his into to Elm, Elm Conf, the State of Elm Survey, community building, and more.
In this episode I talk with Adam Chlipala. We talk Coq, proof assistants, getting started, tooling, domains for advancement using proofs, Ur/Web, and much, much more.
In this episode I talk with Mark Allen. We talk his introduction to Erlang, deployment, Mark's various projects, lessons in distributed applications, and much more.
In this episode I talk with Christiano Haesbaert. We talk his experience with the BSD kernel; foray into OCaml and MirageOS, and how OCaml fits in the realm of "systems languages".
In this episode I talk with Scott Wlaschin. We talk on the topic of his upcoming book Domain Modeling Made Functional, and using F# (and ML family type system languages) with Domain Driven Design.
In this episode I talk with Colin Barrett. We talk his intro to Objective C; exploration to Haskell, OCaml, and other languages; diving deep into functional programming; functional Swift; and more.
In this episode I talk with Erik Svedäng. We talk his background in functional programming, game development, and creating Carp, a statically typed Lisp for use in game development.
In this episode I talk with Dan Friedman. Dan gives shares stories of his history working with Lisp, including topics such as the power of Lisp, and tips for introducing a language.
In this episode I talk with Evan Hubinger. We talk his introduction to programming, creating the Coconut language, building Coconut as additive to Python 3, what makes a good language, and much, much more.
In this episode I talk with Sander Spies. We talk his intro to functional programming; what made OCaml click for him; the whats, whys, and hows of Reason; and much more.
In this episode I talk with Irina Guberman. We talk her entry into programming, coming across Erlang at the "perfect time", importance of learning multiple paradigms, programmable hardware, and more.
In this episode I talk with Jay McCarthy. We talk his intro to software, functional programming, Racket, relation between the Unix Philosophy and functional programming, more Racket, continuations, verified programming, and much, much more.
In this episode I talk with Federico Carrone. We talk his Erlang, MLs, Lisps, various other languages, his "This is not a Monad Tutorial" interviews, and much, much more.
In this episode I talk with Baishampayan Ghose, better known as BG. We talk his entry into software development, exposure to Lisp, using Common Lisp, moving to Clojure, and much, much more.
In this episode I talk with Justin Woo. We talk his introduction to functional programming; the transition from ClojureScript to Elm to PureScript for side projects; the appeal of PureScript; evangelizing PureScript and more.
In this episode I talk with Bryan Joseph. We talk Elixirscript; the initial seed of an idea, JavaScript interop, runtime semantic differences, and much more.
In this episode I talk with Adelbert Chang. We talk his introduction to programming, functional programming, expressive type systems, Domain Specific Languages, and more.
In this episode I talk with Trisha Gee. We talk about functional programming in Java 8 and beyond, and working to introduce functional programming ideas to developers that just want to get their work done.
In this episode I talk with Niki Vazou. We talk about her introduction to Haskell, Ph.D. and graduate school overview, and all things Liquid Haskell.
In this episode I talk with Rahul Muttineni. We talk his path into software, exposure to functional programming, what lead to the desire to create Eta, what a Haskell on the JVM looks like, and more.
In this episode I talk with Mohit Thatte. We talk his introduction to software, path to Clojure, building a community, putting on a conference, what keeps him excited about Clojure, and more.
In this episode I talk with Ody Mbegbu. We talk his exposure to functional programming, F#, Akka.NET, appeal of immutable databases, and more.
In this episode I talk with Edgar Aroutiounian. We talk his introduction to OCaml, OCaml inter-op with other languages, some of the things in the works for OCaml, and more.
In this episode I talk with Lennart Fridén. We talk his entry into Elixir, working to help build the Stockholm Elixir group, his Journeyman Tour, Mob Programming, and more.
In this episode I talk with 'Ley Missailidis. We talk his introduction Erlang and Elixir, Elm, and the pairing of Phoenix and Elm to reduce the complexity of front-end development.
In this episode I talk with Jared Roesch. We talk his history of functional programming, work on the Rust compiler, dependent types, the Lean Proving Language, and much, much more.
In this episode I talk with Anthony Cipriano. We talk his introduction to functional programming, APL, J, K, the path to writing AntLang, why AntLang, and where AntLang took as its inspiration.
In this episode I talk with Eric Merritt. We catch up on his experience with unikernels, containers, Nix, microservices, the benefits of orchestration platforms to allow developers to focus on solving the business problems, and much, much more.
In this episode I talk with Zeeshan Lakhani. We talk his introduction to functional programming, Clojure, Erlang, distributed systems, session types, Papers We Love, and much more.
In this episode I talk with Jonas Bonér. We talk his introduction to Scala, the Actor Model, Akka, Reactive Programming, Microservices, Distributed Systems, and more.
In this episode I talk with Gabriel Gonzalez. We cover numerous topics around Haskell from stumbling blocks for beginners, to co-routines, to shell scripting with Haskell, to equational reasoning, and much, much more.
In this episode I talk with Nikhil Swamy. We talk F*, dependent types, proving software, Dijkstra Monads, Project Everest for verified HTTPS, and more.
In this episode I talk with Simon Thompson. We cover a broad range of topics from a history of functional programming from the 1980s, to his involvement with Haskell, teaching Haskell and Erlang, the functional programming hype cycle, recent and future work, and much, much more.
In this episode I talk with Bartosz Milewski. We talk his introduction to category theory, teaching category theory, comparison of Monads and other composition patterns in functional programming to composition patterns in object oriented programming, and finish with some philosophical thoughts on category theory.
In this episode I talk with Matthew Butterick. We talk about using Racket as someone who doesn't consider themselves a developer; the power of Domain Specific Languages; Pollen, a DSL for creating web sites; and his book Beautiful Racket.
In this episode I talk with Hardy Jones. We talk his enthusiasm for languages, why types, working in teams, trade-offs, and much, much more.
In this episode I talk with Scott Wlaschin. We talk his introduction to functional programming and F#, making the ideas accessible without needing a math background, functional programming being similar to object oriented programming taken to the extreme, and much, much more
In this episode I talk with Morten Kromberg. We talk his introduction to APL, the APL landscape, what the future looks like for APL, resources for getting started, and much more.
In this episode I talk with Alex Weiner. We talk his introduction to APL, comparison to Assembly and C programming, use in side projects to show examples of APL, discuss the power of APL, getting started with APL, and more.
In this episode I talk with Yan Cui. We talk his introduction to functional programming via Erlang and F#, getting functional languages adopted in a company, type providers, we wrap up with a rundown of a number of different languages, and much more in between.
In this episode I talk with Lars Hupel. We talk his introduction to Functional Programming with Haskell, Scala, and move to working on Isabelle for creating theorems about proving your program.
In this episode I talk with Susan Potter. We talk her introduction to Functional Programming, Haskell, Erlang, reasoning about code, Nix and NixOS, reasonable deployments and environments, and more.
In this episode I talk with Paul Bone. We talk his introduction to functional programming through SQL of all places, exposure to Lisp and Haskell, Mercury Language, his work on parallelism, and more.
In this episode I talk with Eric Bailey. We talk his entry into functional programming; work with Scheme, Clojure, Haskell, and LFE; getting into the LFE community; interop story with other BEAM languages; Exercism.io; and much more.
In this episode I talk with Elise Huard. We talk her introduction to functional programming, the benefit of moving between Haskell and Clojure, her book "Game programming in Haskell", and more.
In this episode I talk with Mark Seemann. We talk his introduction to functional programming and F#, common principles between functional programming and object oriented programming, Haskell, lessons learned, planting the seeds of functional programming, and much, much more.
In this episode I talk with Garrett Smith. We talk his introduction to Erlang, building communities, conferences as a place for serendipity, and more.
In this episode I talk with Andreas Stefik. We cover the human factors side of programming languages and he gives a rundown of what the little research we have on programming language usability.
In this episode I talk with Edwin Brady. We talk Dependent Types and Idris. We cover his background of getting interested in dependent types, getting up and going with Idris, how to participate to drive Idris forward, and much more.
In this episode I talk with Rúnar Bjarnason. We talk his introduction to functional programming, Haskell, Scala, his book Functional Programming in Scala, and more.
In this episode I talk with Brian Lonsdorf. We talk his intro to functional programming, introducing functional programming concepts using JavaScript, function composition, pure functions, and when he decides to choose between dynamic and static type systems.
In this episode I talk with Bridget Hillyer. We talk her introduction to functional programming, ClojureBridge, StrangeLoop, community building, Onyx Platform, and more.
In this episode I talk with Steve Vinoski and Francesco Cesarini. We talk their introduction to Erlang, and designing scalable, reliable systems with Erlang We talk their introduction to Erlang, and designing scalable, reliable systems with Erlang.
In this episode I talk with Matthias Felleisen. We talk his history with Schemes from The Little Lisper, How to Design Programs, to Typed Racket. We also cover teaching math to middle schoolers with Bootstrap, and using programming to teach problem solving and more.
In this episode I talk with John De Goes. We cover his introduction to functional programming, reasons for starting a functional programming conference, evolution of LambdaConf, what to look forward to at LambdaConf 2016, the choice to pick PureScript at SlamData, and more.
In this episode I talk with Kurt Schrader. We talk about his introduction to Clojure, deciding to build a company on Clojure and Datomic, how Datomic changes your thinking about databases and more.
In this episode I talk with Brooklyn Zelenka. We talk her introduction to functional programming, various user groups she has started, her consultancy Robot Overlord, and her Monad Nomad tour.
In this episode I talk with Michael Craig. We talk his introduction to Haskell, doing Haskell on the side and it's impact on his Ruby and Java, using Haskell in production, getting new people up to speed with Haskell, and more.
In this episode I talk with Brujo Benavides. We talk his history with Erlang, work with Inaka, community growth of Erlang, Erlang tooling, and importance of running Dialyzer on your codebase, and more.
In this episode I talk with Claudia Doppioslash. We talk about how she first got into functional programming; her experience with Clojure, Haskell, Idris, Erlang, Elixir, LFE, and Elm; Static vs Dynamic Types; and her goal of showing Functional Reactive Programming as a good way to do game development.
In this episode I talk with David Nolen. We talk his background in Functional Programming, entry into Lisps and Clojure, ClojureScript, Om and Om Next, and the ideas Om next is taking from React, GraphQL, and Falcor.
In this episode I talk with Professor Philip Wadler. We talk the correspondence between mathematics and computation, his research into concurrent distributed systems, and other research in the area with ABCD and BETTY.
Functional Geekery Episode 38 - Dr. Conrad Barski
Functional Geekery Episode 34 - Johnny Winn
Functional Geekery Episode 33 - Richard Feldman and Tessa Kelly
Functional Geekery Episode 30 - ElixirConf 2015
Functional Geekery Episode 29 - Carin Meier
Functional Geekery Episode 28 - Tom Stuart
Functional Geekery Episode 25 - Jim Freeze
Functional Geekery Episode 21 - Andrea Magnorsky
Functional Geekery Episode 19 - Julie Moronuki and Chris Allen
Functional Geekery Episode 18 - Eric Normand
Functional Geekery Episode 17 - José Valim
Functional Geekery Episode 15 - Bruce Tate
Functional Geekery Episode 11 - Simon Peyton Jones
Functional Geekery Episode 9 - William E. Byrd
Episode 4 - Zach Kessin
Episode 3 - Fogus
Episode 2 - Craig Andera
