You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Arne is a developer, public speaker, programming coach, author and open-source contributor. With a passion for both human and programming languages, he has spent the last decade teaching and exploring the finer points of Ruby, LISP, Haskell, Mandarin Chinese, and others.
When not hopping conferences or Pacific islands, he can be found at his home base in Berlin, brewing fine teas while pondering the future of open-source and the web.
Ruby isn't exactly know for being a functional programming, but neither is it known for not being a functional programming. With lambdas, blocks, and Matz himself citing LISP as a major influence, there is very little stopping us from writing code in a functional style.
We'll cut straight through the smugness and jargon that typefies functional programming literature, and go straight to the essence. What does it mean to program "functionally", and what does it buy us. What patterns and techniques can we incorporate to write more flexible, maintainable code, and what are the caveats Rubyists specifically need to look out for.
More Info
This talk has several aspects, it will start by laying the groundwork of what we mean by functional programming, and define key terms like immutable, pure function, closure, in a way that is easy to grasp.
We'll go through several patterns and techniques taken from the FP world, and explain their use and their benefit. This includes zooming in on relevant Ruby features.
Potential topics (still need to decide on scope)
immutability & value objects
function objects & higher order functions
memoization
laziness
persitent data structures
infinte data structures
functional core, imperative shell
helpful gems (hamster, funky, anima)
Finally we will go through some run-time aspects of Ruby, showing strengths and weaknesses. The generational GC in the latest Ruby for example has made using immutable data structures more appealing, but having tail-call optimization off by default means we need to be careful when using recursion.
This will be a very technical talk, but also a practical one, with take-aways that people can start applying straight away. There will also be some lighter touches to make sure there is enough entertainment value.
Notes
I will give this talk for the first time in April at RubyConf Taiwan. I am however working on a book, The Happy Lambda, about this topic, so I have already done plenty of research.
The video from my talk (different topic) at Eurucamp last year should be on-line very soon, which should give you an idea of my speaking style.