Writing software with no defects is extremely difficult and expensive, but the lessons learned from such ambitious projects can inform our approach for a more practical development technique. This talk looks at how principles from zero-defect engineering, functional programming, and refactoring come together to produce robust, readable, and reliable code.
You know that feeling when you look at a piece of code you or someone has written and it has a smell, it's inelegant, or its incomprehensibly complex. And then there's the other feeling, when you see a piece of code that's comprehensible, elegant, and it is ready to adopt the behavior you seek. It's this feeling we want to replicate and enhance. Instigated by a simple tweet, the speaker reaches back in time to explore the foundational practices that lead to our best code.
Starting with Refactoring, we'll reflect on the techniques of change that retain stability while increasing sophistication or reducing complexity. We'll explore how code is a form of conversation and ways that conversation can transpire in a code repository.
Next we will explore how Python has supported the principles and primitives of functional programming from early versions and how the constraints of functional programming lead to robust logic. We'll examine the functional nature of comprehensions and the powerful feature of functions as parameters.
In the main event, the speaker will draw on his early experiences with Zero-Defect Software, where one writes software with literally no bugs, and how these techniques can influence the design and implementation toward a more robust solution, starting with a rigorous but impractical ideal and distilling from that a pragmatic approach that retains much of the benefit of the technique. Integrating the lessons from refactoring and functional programming, a coding approach emerges that promises to enable and empower your development.