Your current filters are…
Inferring from the title, you might think this talk is completely misplaced for a Ruby conference and would better fit in a wedding fair. But the message describes a future trend not only for programming, but for every kind of creative work: love driven development.
Companies like Github and Valve have already implemented a corporate culture based on freedom. Their employees are free to work on whatever they think is important and should be worked on. Some may think: ‘That is chaos! Madness!’ But really, this is how startups work. The major advantage of this kind of corporate culture is: people will love their work. And if they do so, they will give their best and your company will be truly successful.
Ruby is slow, so therefore we let complex calculations run outside a web
request using tools like delayed_job or extract them to C or Java code.
But what if these two options are not available?
In the first part of my talk, I will use an example app featuring a
recommendation algorithm to show you how to load thousands of database
records and the ins and outs of caching object graphs. In a second part
of my talk, I'll discuss writing more efficient and faster Ruby code.
Have you ever heard about that awesome tool that will help you achieve your goals with less effort, that fits perfectly into your workflow and makes your code look sexy? No? Then maybe you should stop waiting for someone to tell you about it. Instead write that tool yourself and share it with the community!
Besides showcasing a couple of those tools you might not yet have heard about, this talk will primarily dive into the process of creating your own tools and improving them by sharing them with others.
One of the biggest problems in web development today is scalability. It's
a big problem, and not always easy to solve. The sheer number of requests
that large applications need to process is huge, and increasing every day.
One of the most elegant and widely adopted techniques to deal with this is
favoring distributed architectures over monolithic ones. Having a distributed
network of tiny apps makes it easier to have a robust, maintainable codebase.
Adopting the Unix philosophy of doing one thing right is a topic that has
been coming up at conferences and on blog posts all over the world lately,
and with good reason.
But is a distributed architecture always the best solution? Is then a
monolithic approach "wrong" from the get go? Sometimes building a distributed
system is worth it, sometimes it just isn't. In this talk I put forward my
thoughts and experiences dealing with refactoring your application into
several small ones, how to build a monolithic app that can be easily
split, how to approach the refactor gradually and incrementally, so as not
to lose the ability to deliver new features, and how to decide when it's
simply not worth it.
by Mike Burns
Object-oriented Ruby is a hot topic in the Rails world and beyond, but it
is not always the appropriate solution.
In this talk I discuss various OO techniques, when to use them, and when
a simpler pattern exists in the functional, declarative, or procedural
world — including, yes, the Rails framework itself. You will leave knowing
when to use an aspect instead of a decorator, a mixin instead of a
presenter, or a monoid instead of a factory.
Topics will include:
Many of us write, maintain and scale Rails applications for a living. And
we enjoy it because we love Ruby. As developers, we love its expressiveness,
conciseness, and the freedom and happiness it gives us. But at the same time,
Rubyists are often attracted to other programming languages and willing to
learn them: Ruby programmers are often eager polyglots.
According to the Sapir-Whorf theorem, our thoughts are constrained by our
language: we think in terms of language. And the more languages we speak,
and the richer those are, the broader our mental universe becomes.
In the same way, different programming languages enable us to think
differently about technical problems.
What if we could write Rails applications using multiple programming
languages? Can you imagine different programming paradigms all running
together in the same application? Passing Ruby, Clojure, Python
objects back and forth, interacting with each other, within the same VM?
Fortunately Rubinius, a high-end Ruby implementation, empowers us with
this possibility. In this talk I'll share my experience with this
approach and explain a bit about the technical foundations implied.
Rails - a word that stirs programmer's blood. It has brought us testing,
easy web app building, database abstraction and hundreds of extension
gems. Why not take it to another level and discover how Rails can be
turned into a real OOP framework? By exploring chosen gems, let's discuss
what MVC really is and how it boosts your AJAX user interface, how to
apply patterns like DCI, dependency injection and POROs to your database
layer and how to expose your Rails system through a real RESTful API.
Also, have you ever tried using Rails helpers outside of Rails, maybe in
Sinatra? Let's do it and learn about some refreshing aspects of this
17th–19th August 2012