Elixir Wizards
Elixir Wizards
Jan 23, 2020
Brooklyn Zelenka on Functional Programming
Play • 39 min

In today’s episode we have one of our favorite recurring guests, Brooklyn Zelenka, joining us once again! Brooklyn has been on the show in both the first and second seasons to speak about Elixir and functional programming. In those conversations, it came up that this topic is far from exhausted, and since Season 3's theme is working with Elixir, we thought it would be great to have Brooklyn on for a third time. Today, Brooklyn does not speak to Elixir specifically though, but on functional programming more broadly. Fission, her company which is working on developing next-generation hostless apps, actually uses Haskel, but Brooklyn has a ton of experience across the board. She gives us some great insights into what makes the functional versus OOP paradigm great and helps us to understand some of the inner workings of both worlds, talking about abstraction, application, data orientation, and more. Interestingly, Brooklyn does employ some imperative programming in her company through the use of Typescript, but uses a functional style to get around the context switch. We spend some time toward the end of the show digging deeper into macros, and Brooklyn helps to revise understandings of them as code which writes more code as well as clarifies the term 'homoiconic' as it relates to ASTs. Brooklyn covers a whole lot more today so hop on for a deep dive into functional programming with today's great guest.

Key Points From This Episode:

• Why Brooklyn uses FPE: it can be reused and reasoned about.
• Two things that functions provide: abstraction and application.
• Data orientation and hiding information: imperative vs functional paradigms.
• Understanding imperative programming: it’s less structured and hard to reason about.
• Challenges experienced imperative programmers face with functional programming.
• Differences between Elixir, Erlang, Haskel, Elm, and Clojure.
• Using Clojure: tradeoffs, distinctions, tooling, flexibility, and compatibility with Java.
• The language Brooklyn could use if only one existed: Racket.
• Bridging functional and imperative paradigms through disciplined use of style.
• Segfaults in Haskell related to its compatibility with lib C.
• How to use Musl instead of lib C by employing docker files.
• Algebraic types and why static types aren’t hindrances in functional languages.
• Preferences for tests or proofs and their role in finding types valuable.
• Macros as compile-time functions that are difficult to debug.
• A definition of a ‘homoiconic’: high-level syntax which represents the AST.
• What makes C macros different from Lisp ones.
• Architecture in Elixir and the need for a more user-friendly Haskell.

Links Mentioned in Today’s Episode:

SmartLogic — https://smartlogic.io/
Brooklyn Zelenka on LinkedIn — https://www.linkedin.com/in/brooklynzelenka/
Fission — https://fission.codes/
Seven Languages in Seven Weeks — https://www.amazon.com/Seven-Languages-Weeks-Programming-Programmers/dp/193435659X
Chris Keathley — https://keathley.io/
Hackers and Painters — https://www.amazon.com/Hackers-Painters-Big-Ideas-Computer/dp/1449389554
Paul Graham — http://www.paulgraham.com/

Special Guest: Brooklyn Zelenka.

More episodes
Clear search
Close search
Google apps
Main menu