Functional Programming in 40 Minutes • Russ Olsen • GOTO 2018

The speaker, a self-proclaimed programming language enthusiast, introduces the topic of functional programming. He aims to demystify the concept, emphasizing its simplicity despite common misconceptions. The speaker's focus is on functional programming with closures, a specific flavor of the paradigm. The talk is structured to explain what functional programming is, its origins, the experience of programming functionally, especially for beginners transitioning from object-oriented programming, and the practicality of functional programming in real-world applications.

The speaker discusses the evolution of software systems, which often start well-designed but become messy over time due to changing requirements and bug fixes. He likens the process of refactoring to starting with a 'clean sheet of paper,' where existing working components are retained while the system is reorganized under a new paradigm. The speaker suggests that traditional object-oriented programming may be reaching a point where it needs such a refactor, hinting at functional programming as a potential new paradigm.

The speaker explores the idea of borrowing concepts from mathematics to improve programming practices. He highlights the work of mathematicians who use functions as an organizing principle, drawing a distinction between mathematical functions and programming functions. The speaker introduces the concept of pure functions, which are akin to mathematical functions in their predictability and lack of side effects, as a potential foundation for a new approach to programming.

The speaker addresses the issue of mutable data structures in programming, which can lead to complex and hard-to-trace bugs. He proposes a solution to this problem by advocating for the use of immutable data structures. These structures, once created, cannot be altered, thus preventing unexpected changes and making programs easier to reason about. The speaker also introduces the concept of persistent data structures, which allow for efficient copying and modification without the overhead of traditional copying mechanisms.

Despite the benefits of pure functions and immutable data, the speaker acknowledges the necessity of side effects in programming, as they are often the desired outcomes of software applications. He discusses the need for a bridge between the functional programming paradigm and the real world, where side effects like file writing or database updates occur. The speaker introduces the concept of atoms in the context of the Clojure programming language, which serve as a controlled way to handle mutable state within a functional paradigm.

The speaker discusses the advantages of functional programming when it comes to concurrency. Immutable data structures inherently prevent certain classes of concurrency issues, as one thread cannot inadvertently change data that another thread is using. The speaker also explains how atoms in Clojure can be used to safely update state across multiple threads, thus providing a form of collision detection and resolution without losing updates.

The speaker emphasizes that functional programming is not a magic solution to all programming problems. It does not eliminate common issues such as off-by-one errors or the potential for writing bad code. However, it does offer a structured approach to writing programs that can lead to fewer concurrency-related issues and more maintainable code. The speaker encourages programmers to try functional programming to experience its benefits firsthand.

The speaker presents the Pedestal library as a case study to illustrate the practical application of functional programming in a production environment. Pedestal, a set of libraries used extensively in the Clojure community, consists of a large number of functions, a few protocols for defining interfaces, and other components like agents and atoms. The speaker uses Pedestal to demonstrate the dominance of functions in functional programming and to argue for the effectiveness of the paradigm in building robust applications.

In conclusion, the speaker reflects on the nature of functional programming, emphasizing that it is about writing a large number of functions within a structured and testable framework. He likens the initial constraints of functional programming to learning to ride a bicycle, where initial challenges give way to greater ease and efficiency. The speaker asserts that functional programming works and encourages the audience to explore it further.