Legacy Code Rocks

Legacy in Functional Programming With Eric Normand

Apr 19, 2021

Eric Normand, an experienced functional programmer, discusses legacy code, abstract data transformations, and the importance of immutability and invariance in functional programming. He explores the differences in reasoning and control between functional and object-oriented programming and shares his experiences working with old computers and transitioning to PCs.

49:40

Creator website

Episode guests

Eric Normand

AI Summary

AI Chapters

Episode notes

Podcast summary created with Snipd AI

Quick takeaways

Refactoring legacy code by breaking down large actions into smaller actions and calculations, implementing immutability, and creating invariants improves maintainability and reliability.

Legacy code bases with functional programming present challenges such as the presence of mutable and global variables, but also offer benefits like improved modularity and the ability to create domain-specific languages within the programming language.

Deep dives

The Importance of Refactoring Legacy Code

Legacy code is often associated with outdated technology and old systems, but it represents a significant part of the software landscape. Refactoring legacy code is crucial to modernizing and maintaining software systems. In the podcast episode, the speaker highlights the importance of viewing legacy code in a different light. Legacy code is the result of past developers' work and represents their legacy. The episode emphasizes the need to refactor large actions into smaller actions and calculations, implementing immutability, and creating invariants. By doing so, developers can improve the maintainability and reliability of legacy code.

Introduction

2min

Legacy Code and Baked-in Experience

18min

Breaking Down Code and Testing in Functional Programming

7min

Testing in Functional Programming

5min

Importance of Immutability and Invariance in Functional Programming

3min

Reasoning and Control in Functional and Object-Oriented Programming

9min

Old Computers and Emulator Software

2min

Transition from old machines to PCs and challenges it brought

3min

Common Lisp was written in the 80s as a kind of an amalgam of the existing Lisps at the time. To make sure the Common Lisp would stay relevant, it was made backward compatible so that existing legacy systems could run on it. One thing in common to these big old systems like Lisp is a lot more mutation, and the cool thing about this legacy is that it has a baked experience – it learns and it has learned.

Today we talk to Eric Normand, an experienced functional programmer, trainer, speaker, and consultant on all things functional programming. He started writing Lisp in 2000 and is now a Clojure expert, producing the most comprehensive suite of Clojure training material at purelyfunctional.tv. He also consults with companies to use functional programming to better serve business objectives.

We talk about problems in legacy code basis utilizing functional programming, the abstract nature of programs, the wisdom of Lisp, and more.

When you’re done listening to the episode, make sure to check out Eric’s Clojure training and his podcast, as well as connect with him on LinkedIn.

Mentioned in this episode:

Eric Normand on LinkedIn: linkedin.com/in/eric-normand-61a70366/

Eric Normand’s podcast: Lispcast.com

Eric Normand’s websites: https://lispcast.com and https://purelyfunctional.tv

Eric Normand’s Clojure training: Purelyfunctional.tv

Eric Normand’s book Grokking Simplicity: https://www.manning.com/books/grokking-simplicity?utm_source=lispcast&utm_medium=affiliate&utm_campaign=book_normand_grokking_8_20_19&a_aid=lispcast&a_bid=72596968Use discount code TSSIMPLICITY for 50% off.