In his talk titled "Scaling Ruby with Actors, or How I Learned to Stop Worrying and Love Threads" at RubyConf 2011, Mike Perham explores the challenges and advantages of using threads and actors for scalability in Ruby applications. He begins by discussing his background as a hobbyist researcher focused on performance and scalability in Ruby, emphasizing that the community often uses Ruby for its enjoyment rather than its performance characteristics.

The main points of his talk include:
- Concurrency vs. Parallelism: Perham explains the distinction between concurrency, which allows multiple operations to occur at once, and parallelism, which requires multiple CPU cores for true simultaneous execution.
- Efficiency of Threads: He argues that threads can be more efficient than processes in certain scenarios, highlighting the simplicity of creating threads but also cautioning about the complexity introduced when sharing data between them, particularly with the necessity of locks.
- Locks and Contention: Perham critiques locks as being problematic due to potential contention issues that significantly hinder performance, particularly in Ruby versions where only one thread can execute at a time (due to GIL).
- Alternatives to Traditional Concurrency: He offers various solutions, including the actor model, which encapsulates state and message passing, thus avoiding direct memory sharing.
- Actor Libraries in Ruby: He reviews existing actor libraries in Ruby, including Actor.rb and Celluloid, sharing examples of how these libraries implement the actor model, emphasizing Celluloid’s more idiomatic approach to the actor concept.
- Future Directions: Perham discusses the need for further exploration of higher-level abstractions such as software transactional memory, atomic instructions, and standardizing actor implementations in Ruby.

For example, Perham shares a benchmark comparison demonstrating performance enhancements when using atomic operations in JRuby, illustrating how efficient concurrency can be achieved with the right tools.

In conclusion, Perham stresses that concurrency is inherently difficult, regardless of the techniques employed. He advocates for continued innovation and improvement in Ruby's concurrency tools to enable developers to enjoy writing scalable applications without losing the fun of programming.