Medium 56633

Piotr Szotkowski

Cheap Science Officer
Follow me
groups
0
events
31
presentations
30
About

Piotr is a hacker scientist: an assistant professor at Warsaw University of Technology, Cheap Science Officer at Rebased and a founding member of Warsaw Hackerspace. When not coding (or talking about coding) he coaches at Rails Girls Warsaw and Rails Girls Summer of Code and organises Warsaw Ruby Users Group.

  • From Profiling Ruby to Frankenstein Programming

    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.

  • From Profiling Ruby to Frankenstein Programming

    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.

  • From Profiling Ruby to Frankenstein Programming

    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.

  • Persisting Relations Across Time and Space

    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.

  • Decoupling Persistence (Like There’s Some Tomorrow)

    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?).

  • C-C-C-Combo Maker

    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.

  • Decoupling Persistence (Like There’s Some Tomorrow)

    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?).

  • From Here to Eternity

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

  • 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.

  • Ruby on the Command-Line

    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.

  • Persist, Little Objects!

    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.

  • Fly, You Tools!

    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 (like Git or PostgreSQL); tricks which make using these tools such a pleasure, regardless whether it’s for shaving yet another yak or saving one’s own skin.

  • Teaching Ruby Basics

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

  • Bogus: A Brief Introduction

    An introduction to Bogus, a test double library that tracks doubles’ sync with reality.

  • They Hear Me Typin’, They Hatin’

    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 ☭.

  • Standard Library, Uncommon Uses

    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!

  • Fly, You Tools!

    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.

  • Integration Tests are Bogus

    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.

  • Standard Library, Uncommon Uses

    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!

  • Weak References Strongly Held

    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!

  • Ruby’s Gems

    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!

  • Ruby Smells

    Writing good object-oriented code is hard: object boundaries are not always as clear-cut as we’d like, their responsibilities and reasons to change tend to grow over time, inter-object coupling makes isolated testing complicated – and emergency refactorings are tiresome, gnarly and seem to always happen too late. At the same time it’s often hard to see the exact moment when a simple refactoring would save a given class from taking the wrong turn, and real-life projects tend to have real-life sadlines with their tireless chants of ‘let’s refactor this in the next sprint’.

  • Ruby Smells

    Writing good object-oriented code is hard: object boundaries are not always as clear-cut as we’d like, their responsibilities and reasons to change tend to grow over time, inter-object coupling makes isolated testing complicated – and emergency refactorings are tiresome, gnarly and seem to always happen too late. At the same time it’s often hard to see the exact moment when a simple refactoring would save a given class from taking the wrong turn, and real-life projects tend to have real-life sadlines with their tireless chants of ‘let’s refactor this in the next sprint’.

  • Ruby Smells

    Writing good object-oriented code is hard: object boundaries are not always as clear-cut as we’d like, their responsibilities and reasons to change tend to grow over time, inter-object coupling makes isolated testing complicated – and emergency refactorings are tiresome, gnarly and seem to always happen too late. At the same time it’s often hard to see the exact moment when a simple refactoring would save a given class from taking the wrong turn, and real-life projects tend to have real-life sadlines with their tireless chants of ‘let’s refactor this in the next sprint’.

  • Ruby OOP Code Smells

    TBA

  • Ruby Smells

    Writing good object-oriented code is hard: object boundaries are not always as clear-cut as we’d like, their responsibilities and reasons to change tend to grow over time, inter-object coupling makes isolated testing complicated – and emergency refactorings are tiresome, gnarly and seem to always happen too late. At the same time it’s often hard to see the exact moment when a simple refactoring would save a given class from taking the wrong turn, and real-life projects tend to have real-life sadlines with their tireless chants of ‘let’s refactor this in the next sprint’.

  • They Hear Me Typin’, They Hatin’

    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 ☭.

  • Integration Tests are Bogus

    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.

  • Ruby’s Gems

    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!

  • Ruby Smells

    Writing good object-oriented code is hard: object boundaries are not always as clear-cut as we’d like, their responsibilities and reasons to change tend to grow over time, inter-object coupling makes isolated testing complicated – and emergency refactorings are tiresome, gnarly and seem to always happen too late. At the same time it’s often hard to see the exact moment when a simple refactoring would save a given class from taking the wrong turn, and real-life projects tend to have real-life sad lines with their tireless chants of ‘let’s refactor this in the next sprint’. Ruby’s dynamism means static code analysis is tricky (to say the least), but tools like RuboCop and Reek bravely show it’s not impossible. This talk shows how to effectively use such tools, make informed decisions on when and how to refactor, and – most importantly – learn over time to spot potential code smells right when they’re introduced.

Publications

There are 0 publications

Want to get more information? Join our newsletter!