ActiveRecord can't do it? Arel can! Active Record is awesome. But how does ActiveRecord handle generating complex SQL queries? Under the hood it's handled by Arel. Most of the time, Rails developers don't have to know about how Arel works. But sometimes Active Record can't satisfy our needs. Also Arel has many strengths not exposed through Active Record. Let's experiment with Arel directly and wield great SQL power in database agnostic way. Oh and did I mention, this is a fun talk, even for us, to “perform”.

The Ruby codebase and standard libraries make heavy use of mutable objects, as does pretty much any mainstream language. Mutable objects are not thread-safe, comparatively harder to maintain and write tests for, and with the resulting tests being slow and brittle. Thus, it becomes very hard to understand applications and libraries written using mutable object states to pass values around and perform operation on those values. Immutability resolves a lot of concurrency issues (race conditions, dirty read/write etc.), and also simplifies the codebase and test cases.

“Internet of things” is the concept of basically connecting any device with an on and off switch to the Internet. IoT has been possible through devices like Arduino, Raspberry Pi and many more. Although most of the APIs to work with them are available in Ruby, I haven’t seen many projects programmed in Ruby, but C++, Python or JS. I would like to share my approach, resources etc I learned from and show things that are possible. I hope audience would learn new possibilities with Ruby and not have to spent time learning a new language to interact with hardware.

The talk is about the gotchas of ActiveRecord callbacks even in the most common usage patterns and touches upon some possible alternatives to avoid each of these pitfalls. As Rails developers most of us would have inevitably have run into callbacks. This is something easy to get started with but is even easier to lead you into unexpected behaviour in production. Also, due to their unobtrusive nature they can become forgotten landmines. Structured in the popular and fun “WAT” style, the focus is mostly on beginner to intermediate levels, others might find one or two anecdotes surprising.

A confession: I used Git for months without really understanding what was going on. I knew all the basic commands, but I still got stranded when something went wrong. Why did my rebase fail? How did I manage to mess up the remote?

Then I found the key to Git: the unfamiliar .git directory. That was my lightbulb moment. Once I understood the underlying model, everything about Git clicked into place. Things that used to be baffling and complicated suddenly looked simple and elegant.

Let me share this lightbulb with you. It will take you less than an hour to wrap your head around Git.

The number of users a web app can handle simultaneously is tricky to determine. Often we go by intuition and choose a deployment architecture which is either insufficient or oversized. Most web bench marking tools, like apache bench, are designed to benchmark the web server, and end-up provide unreliable information as the test scenario is far off from real world usage. Capybara, the defacto acceptance testing framework in rails world, combined with rabbitmq, can help us in determining bottlenecks and choosing the right deployment architecture.

Modern distributed systems have aggressive requirements around uptime and performance, they need to face harsh realities such as sudden rush of visitors, network issues, tangled databases and other unforeseen bugs. With so many moving parts involved even in the simplest of services, it becomes mandatory to adopt defensive patterns which would guard against some of these problems and identify anti-patterns before they trigger cascading failures across systems. This talk is for all those developers who hate getting a oncall at 4 AM in the morning

Rubinius is an alternative Ruby language implementation. We would be giving a brief overview of Rubinius Internals and would be majorly talking about the Heap Dump interface that Rubinius provides for analysis of memory dumps.

Put your ActiveRecord Models on a diet! Talk a walk with us through some common code smells, along with tips on how to resolve them.
This is a 90 minute hands-on workshop. We start with a demo Rails app loaded to the gills with code smells and other problems, and then work to use proven refactoring techniques to clean up the code.

Since the release of ruby 2.1, the language has improved in many areas. Lots of improvements to garbage collection, and tuning options Hooks to monitor life cycles of objects, and to monitor GC Compared to other languages like Java, C or c++, Ruby does not have a beginner friendly plug-and-play profiling tool that doesn't require you to patch Ruby. This workshop aims at showing how we can profile Ruby applications, make use of new tracepoints in Ruby to hook into life cycle of objects and make sense of the data collected.