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.
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.
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.
While gaining experience in the development of Rails apps we learn a lot of rules and principles along the way. Some of them become a breakthrough to the way we write code, others are just nice tips. In the talk I present the very basic principles I tend not to sacrifice under any circumstances. No matter if I try DCI, separate domain objects from data objects or just follow the Plain Old Rails Way, no matter if it's 3pm Tuesday or 4am Saturday, they are always with me. And I'll explain why.
In this presentation, we'll be looking at some of the innards of Rails. Column caching strategies, database interaction, object design, and view rendering will be discussed. We'll form links from the back end to the front, looking at the meat of the system. We'll use the information we learn along the way to mold a view of what the future for Rails will hold. Don't worry, we won't bite off more than we can chew!
Sausage making may also be discussed.
Ideas are cheap, but turning them into something more tangible takes a combination of time and money. The two popular choices for funding the growth and development of your idea are either investment or bootstrapping, but what about crowd funding?
Crowd funding is more than just starting up a Kickstarter project, it is about making people and donators feel like they are a part of your story and project. Also, why use Kickstarter at all? Why not roll your own, or get businesses and friends and the community behind you?
This talk will discuss how to approach crowdfunding in an open source world, from pledgie, to kickstarter, to roll your own, to what to give away, and including the all important drunk funding!
And whats a presentation without a little love.travis-ci.org ;)
With a little help from our buddies Node, Backbone, Websockets and NoSQL, we can turn boring old Rails into a crazy new playground. Let's get started!
In my talk you'll learn the basics of CoffeeScript. I'm gonna explain some do's and some don'ts and in the end I'll gonna show you how to survive async callback hell with Iced CoffeeScript.
You know all about NoSQL. You've used Redis as a secondary index, and run MonogoDB with the mongoid gem. That's all there is to it, right?
Nope. Not even close. The new world of databases is bigger and weirder than you might think - from mapreduce, to link walking, to blob indexing, to declarative graph traversal you need only free your mind.
Curious storage techniques that are simpler than the everyday ones
Distributed doesn't mean what you think it means
Rails Contributors is an application that keeps track of the contributions made by all contributors to the Ruby on Rails code base. In this talk we will see the story behind this application, its design, and how it works
Rails development mode is easy, useful and fast: we can spin up an app, edit its source, hit reload in a browser and see the result of our changes. But what effect does this workflow have on our code, and does it really help us? In this talk I'll look at the dark side of development mode — where it falls down, what it does wrong, and how it ultimately encourages us to develop software in the wrong way — and suggest an alternative way of working which avoids these disadvantages.