look at all the talks I give

Teaching Ruby Basics | slides

A short lightning talk about lessons learned while teaching at Rails Girls Warsaw.

Given at Railsberry 2013.

Fly, You Tools! | slides

As developers we heavily depend on our tools of the trade, as oftentimes mastering them means getting out of deep trouble so much faster.

This talk covers some lesser known features of our everyday infrastructure – Git, PostgreSQL and command-line; tricks which make using these tools such a pleasure, regardless whether it’s for shaving yet another yak or saving one’s own skin.

Given at RuPy 2012.

Persist, Little Objects! | slides | video

Object persistence in Ruby is a tricky subject – everyone knows how to do it (‘simply use an ORM, plug it into a relational database and you’re done!’), most know the drawbacks (‘well, sure, you need to use a document database for the more schema-less cases… or serialise the variable parts… and, of course, object references need to be handled separately…’), but few experiment with alternatives.

This talk, after recalling the popular database-driven persistence solutions, concentrates on the less known, but more interesting and often quite useful approaches – from file-based PStore (ideal for small apps), through Candy’s out-of-the-way magic, to MagLev’s true cross-process transparent object persistence.

Given at Arrrrcamp 2012.

Ruby on the Command-Line | slides

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 nits and bolts of writing a command-line application with Ruby – from option parsing and accessing standard input/output to playing nice with POSIX standards like exit codes and signal/interrupt handling.

Given at eurucamp 2012.

PStore: stdlib’s Persistence

PStore is a greatly underappreciated (and vastly uknown) simple persistence library shipped with Ruby. This talk covers it’s vices and virtues, along with real-life usage example in a pet project.

Preview (a lightning talk) from Warsaw Ruby Users Group, August 2012.

From Here to Eternity | slides

A 42-slide, five minute lightining talk on the interactions between Ruby’s Date class and Enumerable module.

Given at Lightning IO 2012.

Decoupling Persistence (Like There’s Some Tomorrow) | slides | video

When I open up a Rails project and the models dir is full of 100% ActiveRecord classes I shudder. Model ≠ Persistence. — Ben Mabey

From DCI to presenters, from Uncle Bob’s architecture talk and Avdi Grimm’s Objects on Rails book to the proliferation of (competing? complementing?) database systems, it seems the time has come to seriously consider decoupling our objects’ persistence from the rest of the application.

This talk – after describing the general vices of strong object/database coupling and the all-too-usual rails g model-driven development – covers the various approaches to separating the objects’ persistence layer, along with their virtues (cleaner, simpler tests! backend independence! no RDBMS-related shortcuts impacting the design!) and potential vices (performance? perceived compexity? YAGNI?).

Given at wroc_love.rb 2012 and Scottish Ruby Conference 2012.

C-C-C-Combo Maker

Ruby is a wonderful high-level lanuguage for expressing ideas and algorithms, but even after rewriting it umpteen times the most sophisticated algorithm can be a CPU-bound bottleneck. Similarly, accessing (especially custom) system devices straight from Ruby is usually doable, but easier via the provided C drivers.

This talk, based on experience with algorithm optimisation and custom device drivers gained when working at the Warsaw University of Technology, shows how easy it is to marry Ruby and C – from writing MRI-targeting C extensions, through building a proper FFI-oriented wrapper, to rewriting crucial – and yet, slow – parts of your codebase in C using RubyInline, without leaving the Ruby method.

Preview (a lightning talk) from Warsaw Ruby Users Group, June 2012.

Persisting Relations Across Time and Space | slides | video

Entities and their relations are the backbone of most Ruby applications – from trivial, one-off command-line utilities to full-blown social network websites. The good old relational databases, while showing extreme abilities in both adaptation and survival, are no longer the obvious choice for persistence – and sometimes obviously not an ideal one.

This talk discusses various entity/relation modeling approaches and different persistence techniques – from rigid schemas in suits to collections of hippie free-form documents; from good old (transactional!) PStore through join-table-happy RDBMS-es and muscle-flexing NoSQL hools to (social!) graph databases, waiting patiently for broader recognition and prime time.

Quite a few interesting Ruby libraries for gluing all this together are also pondered upon – from world-class champions like Active Record and ARel to less known gems like Candy and Ambition.

Given at RubyConf 2011.

From Profiling Ruby to Frankenstein Programming | slides | video

Ruby is ‘known to be slow’ – but what does that exactly mean, does it really matter, and – more importantly – what can we do about this?

This presentation, based on hands-on experience of using Ruby for scientific computations, shows how to profile Ruby applications (including webapps), how to interpret the results and what to do with the bottlenecks – from algorithmic optimisation through using dedicated libraries to rewriting them (in place!) in ‘faster’ languages.

Given at EuRuKo 2010, Ruby and Rails 2010 and Scottish Ruby Conference 2011.

Standard Library, Uncommon Uses | (proposal)

There are tonnes of little- or virtually unknown libraries in Ruby’s stdlib, and they found their way there for a reason. Much like revisiting `Enumerable`’s method list times and again makes you a better Ruby programmer, so does looking into its standard library – not only because there are things you didn’t know existed, but also because the way the’re implemented is often quite enlightening.

This talk shows some of the useful, clever and tricky uses of Ruby’s standard library – like GServer, DRb/Rinda, PStore, Ripper and SecureRandom – that do not require the installation of any gems and can be used in any environment hosting a Ruby implementation. Did you ever want to write your own server, do some distributed computing, don’t worry about persistence? It’s all there; come and see for yourself!

Going Clean and Simple with minitest/spec | (proposal)

The Ruby community is known for praising well-tested code, with a lot of projects being developed in a test- (or spec-) driven fashion. minitest/spec is a simple and minimalistic DSL for behaviour specification and behaviour-driven development, gaining popularity ever since being a part of Ruby 1.9 standard library.

This talk presents minitest/spec’s virtues and vices, the benefits and drawbacks of mocking with minitest/mock, as well as the interesting world of asserting algorithmic performance with minitest/benchmark.