Dave Thomas is recognized internationally as an expert who develops high-quality software–accurate and highly flexible systems. He helped write the now-famous Agile Manifesto, and regularly gives inspiring and controversial speeches on new ways of producing software. He is the author of six books, including the best selling The Pragmatic Programmer: From Journeyman to Master and Programming Ruby: A Pragmatic Programmer's Guide. In this episode, we discuss everything from learning computer science in an academic setting, test-driven development, and state to architecture, libraries, and what Dave loves about what he does. Dave talks about his students, both those who are passionate and those who are just going through the motions, as well as his own experience of being a student. He explains to us what he means when he said he doesn’t write unit tests at an Elixir conference in Austin recently, we talk about his favorite and most rewarding books, and Dave gives us a really unique answer to our architecture question. We discuss domain-driven design, microservice architectures, and Elixir libraries, and Dave shares why is so passionate about what he does. Tune in to hear some of Dave’s strong opinions on programming!
Key Points From This Episode:
The Coding Gnome and how it bridges the gap between learned and practical experience.
Dave talks about being a lecturer at SMU and why students aren’t prepared for the real world.
Why Dave stopped teaching Elixir at SMU.
Students who study computer science for passion versus those who study it to get a job.
Dave talks about his experience of studying computer science at university.
The inspiring and controversial keynote addresses Dave has given at conferences.
What it means when Dave said he doesn’t write unit tests and the projects he’s working on.
The culture around test-driven development and writing tests when Dave was at university.
Dave tells a story about writing the incoming telex switch for the UK.
Why the first edition of Programming Ruby was Dave’s favorite book to write.
Why The Pragmatic Programmer is the book Dave is most proud of.
Dave isn’t currently writing a new book, so he can concentrate on pseudo-course material.
Dave explains the process of developing a narrative arc when writing a technical book.
What the state of a system is and how it is distinct from data.
Dave describes why he believes architecture is a misunderstood and borrowed metaphor.
Dave’s opinions on buzzwords like domain-driven design and microservice architectures.
The status on The Component Library, as mentioned by Dave in his EMPEX 2018 keynote.
Getting involved with publishing Elixir libraries and what his process looks like.
How Dave likes to receive product specification when dealing with clients.
What Dave loves about the programming industry.
Why Dave doesn’t write Elixir anymore and why he became frustrated with it.
Where Dave is going from here to how best to express what he wants.
Final advice from Dave, not to abandon Elixir if it makes you happy.
Links Mentioned in Today’s Episode:
Dave Thomas on Twitter – https://twitter.com/pragdave
The Coding Gnome – https://pragdave.me/
The Coding Gnome Training — https://codestool.coding-gnome.com/
Agile Manifesto – https://agilemanifesto.org/
The Pragmatic Programmer – https://pragprog.com/book/tpp20/the-pragmatic-programmer-20th-anniversary-edition
Programming Ruby – https://en.wikipedia.org/wiki/Programming_Ruby
Robert Kowalski on Wikipedia — https://en.wikipedia.org/wiki/Robert_Kowalski
Dave Thomas on Wikipedia — https://en.wikipedia.org/wiki/Dave_Thomas_(programmer)
Space-state representation — https://en.wikipedia.org/wiki/State-space_representation
Christopher Alexander — https://en.wikipedia.org/wiki/Christopher_Alexander
A Pattern Language — https://en.wikipedia.org/wiki/A_Pattern_Langu