I listened last night. Excited to hear the rest of the series! This one was a little light on content, but it sets the stage. I liked the point near the end of there being analogues to familiar OOP concepts, so it's not like you need to repeat the 20 years of experience to become skilled at this new way of thinking. I've definitely found that to be true, and other languages already give a starting point, even Java. For example, even before Java introduced lambdas with jdk8, you could already do things with map, filter and reduce, either with libraries like Guava or on your own. And it wasn't a crazy leap really, it was something you could refactor toward by extracting the part that changes from the part that stays the same. Even with anonymous classes being the only mechanism, you could have HOFs; lambdas just made it that much more expressive. Similar with immutability, where, especially if you work on a multithreaded system, you've likely adopted it. And with Java records, it becomes much more expressive to create value types. What I'm hoping to hear in later episodes is some insight on how to put those things together using functional design principles, specifically around how to organize or architect larger systems. There's so much out there for OOP around repository patterns and coding to interfaces. I'd like to better understand how to put together my "bags of data" and my functions in a way that's not just going to turn into an unwieldy mess as the project grows.