Your current filters are…
A fun code analysis.
ZeroMQ is a socket abstraction and concurrency framework that's changing
the way we think and reason about distributed systems. Mailboxes, atomic
message delivery and swappable transports allow for fast, flexible and
resilient network topologies. Its I/O model also sits very well with
all Ruby implementations. In this talk we'll discuss:
by Jana Vogel
Websockets are fun for chats and online games. But are there serious
uses? We developed a warehousing interface using websockets and slanger
that enables every workstation to see all current shipments in realtime.
With only Firefox or Chrome as target platforms, this was an easy and
pleasurable task. This talk will run you through the details of such a
system from front to back and also show the most common pitfalls so that
you don’t have to find them out yourself.
Ruby, thanks to its various frameworks, is known to be *the* language
for web applications – and recent developments in graphic libraries
make it a worthy contestant in the world of GUI-driven desktop
programs. But Ruby is also great for writing command-line applications;
the ability to mix no-boilerplate top-level functions with full-fledged
OOP means its usage can vary from one-off trivial scripts to
complicated, option-heavy command-line powerhouses.
This talk presents the nuts and bolts of writing a command-line
application with Ruby – from option parsing and accessing standard
input/output to playing nicely with POSIX standards like exit codes and
As of Rails 3.2, plugins are officially deprecated. They have been
replaced by Rails Engines, a class of public methods for hooking into
Rails applications. This session will explain how to write a Rails Engine
from scratch or convert your existing plugin to an engine. It will also
cover best practices for making your engine play well with others and
determing when to factor pieces of your existing Rails application code
into an engine, for reuse across multiple applications.
by James Coglan
There's been much talk in the Rails community lately about more strongly
object-oriented approaches to design. The argument goes, we should create
more maintainable applications through modular code, focusing on the
Single Responsibility Principle, Dependency Injection, and so on. These
approaches tend to be talked about in quite abstract terms, cited as
being 'good for testing' or simply 'the right way to do OOP'. But really
they're just a means to an end: how do you know when one of these
approaches is good for you?
In this talk you'll see several examples of the real-world uses of dependency
injection I've used in my own projects. You'll say how and why DI emerges
from the program's design goals, how it affects the implementation, and
what effects it has on the project's structure, and you should gain enough
understanding to judge when to introduce it in your own work.
RubyMotion is a revolutionary toolchain for iOS development using Ruby.
With RubyMotion, developers can finally write full-fledged native iOS
apps in Ruby, the language you all know and love. In this session, we will
cover what RubyMotion is and how easy it is to write an app with it.
by Srdan Kvrgic
One of the biggest challenges when handling big data is making sure your
system is coherent after an unexpected crash or machine failure. Designing
your system for idempotency will make sure you can reprocess parts of your
data to fill in the gaps without accidentally affecting the good data.
Once you've got the idempotency down, you are free to venture boldly into
a veritable Narnia* of scaling solutions.
This talk will describe the problem and offer a couple of solutions by
looking at some real-life implementations.
A lot of the principles of clean code are forgotten when writing documentation.
Have a single source of truth and don't repeat yourself. Avoid writing brittle code. Use ubiquitous terminology and choose searchable names. Be consistent in your formatting. Test your code. Refactor and practise successive refinement. Don't write any more than you need to.
These principles of clean code can be applied with great effect to the production and maintenance of documentation, but there's more to it than that. Code needs to satisfy machines and coders. Documentation needs to satisfy people who perform a range of different tasks: from cursory inspection through to intensive development.
This talk will review relevant principles and examine real-world examples, leaving you with a practical mental checklist for writing documentation that will help your users and your software thrive.
You don't know it yet, but you're like Peter Parker, before he was bitten by a radioactive spider. You're Bruce Wayne, before his parents were killed. You're the daughter of Hyppolyta and Zeus.
How are you putting your abilities to use? You're probably already giving back to the tech community by writing great open source projects. However, you can make a much greater difference by stepping outside your field for a moment – and by returning afterwards, with new ideas, and experiences.
I'll show one example of this – doing field work in preserving endangered languages in Papua New Guinea, using my knowledge in technology. With Google stepping in to help save Endangered Languages, this is rapidly becoming a topic of great importance.
Chances are, you can't just run away to a strange faraway place. So what can you do, right now? What's your calling? Follow it!
Ideas we've been talking about for the last couple of years are finally
becoming a reality, and DataMapper 2 is shaping up this year. I'll
show you what it's like to say good bye to ActiveRecord -- it's awesome,
17th–19th August 2012