look at all the talks I give

Ruby’s Gems | slides
The Ruby ecosystem is known for its plethora of gems (and – sadly only a few – of its standard libraries), but the base interpreter itself is a treasure trove with small, beautiful jewels of pleasant syntax and fairly unknown, but elegant solutions that spring to help in the most surprising circumstances.
This talk covers some of the lesser known pieces of Ruby’s core (think ‘obscure, but highly-useful-when-applicable Enumerable methods’), syntax and general language ideas like callables and case matching. Come and see how Ruby can help you before the first require!
Given at RubyConf Portugal 2014.
Weak References Strongly Held | slides
Ruby’s standard library is full of little-known… well, gems of interesting code – which might not be needed on a daily basis, but are super-useful when required. From continuation and etc to tsort and weakref, learning about them means not only they might save you one day, but also make you a better developer (even if by researching the question ‘why on Earth would anyone package such a thing…?’ Come and learn about the libraries you’re already using!
Given at ArrrrCamp 2014.
Standard Library, Uncommon Uses | slides | video
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 PStore, GServer, Abbrev, DRb and IPAddr – 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!
Given at ArrrrCamp 2013 and BaRuCo 2014.
From Here to Eternity eurucamp | slides
A 43-slide, five minute lightining talk on the interactions between Ruby’s Date class and Enumerable module.
Given at wroc_love.rb 2014.
Integration Tests are Bogus | slides | video
The Ruby community embraced testing early, with many developers switching full-time to test-driven development (and, more importantly, test-driven design); discovering the domain of a given problem and the mechanics required to make objects interact painlessly by implementing a system from outside in are oftentimes eye-opening experiences.
Whether you like to write well-isolated (and fast!) unit tests or need to implement the outside of a system without having the inside nits-and-bolts in place beforehand there’s a plethora of stubbing and mocking libraries to choose from. Unfortunately, heavy mocking and stubbing comes with a cost: even with the most well-tested-in-isolation objects you can’t really say anything about their proper wirings without some integration and end-to-end tests – and writing the former is often not a very enjoyable experience.
This talk covers a new player on the Ruby testing scene: Bogus, a library for stubbing, mocking and spying that goes the extra mile and verifies whether your fakes have any connection with reality – whether the faked methods exist on the actual object, whether they take the right number of arguments and even whether tests for a given class verify the behaviour that the class’s fakes pretend to have.
With Bogus quite a few of the famously derided integration tests come for free; a change to a method’s name or its signature will make all of the related fakes complain, and all the missing pieces of a system written from outside in will present themselves ready to be implemented.
Given at wroc_love.rb 2014.
Fly, You Tools! | slides | video
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 and Kod.io 2014.
They Hear Me Typin’, They Hatin’ | slides
Mechanical keyboard, how do I love thee?
Let me count the ways… <clickety> <click> <clee>
As programmers we spend a significant amount of our time typing, and – given the abundance of laptops – we often do it on whatever keyboard was chosen by our hardware’s manufacturer. While certain laptop brands are known to have stellar keyboards (and no less famous pointing devices), some of us yearn for the good old times of IBM Model M; yes, you could hear them from across the building, but once you played with one for some time you grew way more tolerant of its constant – if not distant – clicking.
This talk covers the current state of the mechanical keyboard world, the replacable keycap craze and all the fun you can possibly squeeze out of your daily fingertip companion – including some tips on how to configure your system to easily input all the weird characters needed now and then, from ♥ and ‰ to mëtäl ümläuts and ☭.
Given at eurucamp 2013.
Bogus: A Brief Introduction | slides
An introduction to Bogus, a test double library that tracks doubles’ sync with reality.
Given at Warsaw Ruby Users Group, July 2013.
Teaching Ruby Basics | slides
A short lightning talk about lessons learned while teaching at Rails Girls Warsaw.
Given at Railsberry 2013.
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.