Sessions at Railsberry 2012 on Thursday 19th April

For a long time, the de facto way of doing multi-core concurrency was using threads. However, the complexity of manipulating threads and state affected negatively how developers perceive concurrency. Fortunately, languages like Clojure and Erlang implement new paradigms that aim to make concurrency easier. In this talk, José Valim is going to discuss the role state play in concurrency and introduce different paradigms for multi-core concurrency, like Actors and Software Transactional Memory, explaining their trade-offs and why they matter to us developers.

It's funny how things change. Smart ideas end up ruining everything. Quick hacks end up becoming established practice. How we've written Ruby has changed over the last fifteen years. We have this vague notion of "code quality", but what does that actually *mean*? Let's grab a whole bunch of Ruby projects, pick them all apart, and see what they say about making successful, lasting projects.

Ruby is pretty unique among scripting languages in having not only one but six (!) fairly mature runtime environments -- MRI, Rubinius, JRuby, MacRuby, IronRuby and MagLev -- each of them with specific strengths.

In this talk we will first give a brief overview of planet Ruby and its continents. Then we will embark together on a journey into the deepest concurrency jungles on Java island, where strange beasts like Kilim, Jetlang and Akka roam. With a little luck, we might even encounter the legendary Disruptor!

Using examples taken from actual production JRuby code, we will demonstrate how the power of the JVM plus the rich ecosystem around it are an ideal complement to the expressiveness of Ruby -- and how this killer combination can be used to fully exploit modern multicore hardware.

This talk will make you much faster with vim.

Most people that start learning vim get stuck in a rut right around low-intermediate. They can get everything done, but not very quickly. Lots of people never get any faster from here.

This talk is targeted at users of vim aren't satisfied with where they are, and want to learn to write and edit code at breakneck speed. We'll focus on the knowledge and philosophy necessary to keep making huge leaps in efficiency and to approach expert status. Expect a talk jammed full of specific tips and general advice that you can apply immediately.

No slides for this talk, just live vimming. Bring your laptop to follow along.

What does really happen when we call a method? How do the different Ruby implementations actually figure out what code to execute? What plumbing is going on under the hood to get a speedy dispatch? In this talk we will have a look at the internals of the the major Ruby implementations, focusing on their dispatch. From look-up tables and call site caches, to inlining and what on earth is invokedynamic? Fear not, all will be explained!

So you heard that Rails is not good for doing APIs. A robust framework with a extended view layer and an asset pipeline cannot produce fast APIs. Right?

Wrong! In my talk I'll go over how to have a fast API within your Rails application, with topics including:

• Understanding what is actually happening when your Rails app is producing the response
• Minimizing external calls to a minimum
• Digging deeper within ActionController to get extra juice
• Decoupling representation to optimize performance

This talk is based on what we've done at Future Simple to tune our Rails apps and the awesome work Rails Core is doing to better support APIs.

Every experienced Rails developer understands the need to break that monolithic application into smaller, manageable components. Unfortunately, most seasoned developers envision nightmares of SOAP, RPC, DCOM, CORBA, Web Services, DDS, and WCF when they hear the word "services."
How do we build a lean confederation of applications without falling into the same traps that gave the phrase SOA such a bad name? We'll look at the following topics:

• Knowing when it's appropriate to build as an SOA
• The pitfalls of maintaining distributed systems
• Using the right framework (and language) for the job
• Patterns and techniques for developing resilient and easy to maintain SOAs
• Decoupling services through queues and gateways
• Clear patterns for painlessly testing services

This talk is a distillation of our experiences running large distributed systems at Engine Yard and the Southern California Earthquake Detection Center.

Rails Girls is a workshop for total non-beginners into the world of web building. Organized in Helsinki, Singapore, Shanghai, Tallinn, Berlin and now in Krakow Rails Girls aims to give girls the tools and vocabulary to build the web as they see it. This time we'll share the secrets and social glue of explaining scaffolds, SQLs and servers - and how to find 100+ girls who want to learn to code just about anywhere. Your cookbook to the world of getting girls excited about unicorns, gems and bacon.

*Speaker grew up in Spice Girls era and never let go of girl power, but women, ladies, females ok too.

The talk will cover the process around developing and maintaining a large SaaS product that we can also sell as a bundled package. This will cover how we manage the development process, how we ship it to customers, and how it's different than traditional "enterprise" products. It will go into all of the frustrations and joys of maintaining a complex rails codebase that can move very very quickly.