It was a very Ruby weekend over the 18th and 19th of March at the wroc_love.rb conference! It’s our third time supporting this awesome event, and it only gets better.
Over the weekend a lot of familiar faces from the Ruby world converged on Wrocław. We came from all corners of the globe to exchange different points of view, and debate the finer points of the Ruby programming language and its ecosystem.
Wroc_love.rb is one of the largest and most recognizable Ruby programmers community events in Europe, with over 200 participants and 10 speakers; 5 iRonin team members in all attended the conference.
The Information Technology building at the University of Wroclaw campus set a brilliant scientific atmosphere and tone to the event. Here we could experience various technical talks: lectures, panels, brain storms, lightning talks - oh and we can’t forget about those mysterious discussions during the after party!
- Predicting Performance Changes of Distributed Applications - lecture, materials
- We All Make Distributed Systems - lecture, materials
- Fault Tolerance in Ruby - lecture, materials
- Automated Type Contracts Generation for Ruby - lecture, materials
- Bindings in Ruby - Behind the Magic of Blocks - lecture, materials
- Panel: Ruby vs Elixir (this one got heated up!) - lecture, materials
- The Overnight Failure - lecture, materials
- Machine Learning to the Rescue - lecture
- Concurrent-ruby v1.1.0: new framework, new way of writing concurrent code! - lecture
Want to know what got our juices flowing during the conference? Here’s a few topical points our team were really digging during talks, enjoy!
Artur’s lightning talk about unexpected case of rescuing exception
During a lightning talk session, our team member, Artur, presented to the group an interesting use case based on a problem we faced in one of our projects. This is a short story of how a rescuing Exception class can compromise your codebase and break your tests. If you want to hear more, check out our post that describes the issue in greater detail - a must read for devs.
We All Make Distributed Systems
Łukasz liked the interesting talk delivered by Wojciech Rząsa (Rzeszów University of Technology) about predicting performance changes of distributed applications. Based on real-life case studies, he demonstrated, using a model described in Ruby-based DSL, how we can simulate possible application performance change, according to what kind of architecture we decide to use.
The first case study was about the Rap Genius - Heroku dispute. The cooperation between the two sides was going very well until the time when Heroku decided to change the way in which its router processes requests. Before the change, the router “intelligently” picked the the dyno with the smallest CPU load. After the change - randomly. The simulation results were pretty obvious - in most cases, the intelligent router won the “competition”.
Wojciech also demonstrated to us what would happen if we had more independent intelligent routers, and how it would compare against one random router. It turned out that the more independent intelligent routers we have, the worse the system performs. However, if we pick the right number of these routers it will perform better than one random one.
The second case study addressed the question “Scale or not to scale?”. Wojciech showed the difference in performance between horizontal and vertical scaling, taking the Heroku dynos offer as a reference. The simulation he presented stated that to some point, it’s more beneficial performance-wise to afford 6 standard 1x dynos than 3 standard 2x dynos.
Ruby vs Elixir
Przemek is Elixir fan and was excited to hear more about this programming language. In this years edition there was a comparison of two different programming languages Ruby and Elixir with their frameworks Ruby on Rails and Phoenix. Super interesting and highly heated!
In our next panel topic, everyone agreed that the new version of CoffeeScript doesn’t change anything - currently we have better solutions as ES6/ES7/Typescript. Nonetheless, the community should be grateful for its impact in the past.
The Overnight Failure
Darek participated in an interesting talk given by Sebastian Sogamoso (Colombia) about his experience with a big failure of his company’s product.
The product was a car pooling application, which allowed users to share a car ride with other people while going to work. It had automatic payments for users, and one day this payment system broke down.
The problem resulted in many duplicated payments: users were charged multiple times. The consequence of this bug was very serious: some people were left without any money left in their bank accounts at all!
Sebastian described his entire day (Saturday) when he was dealing with the (very serious!) problem. To sum up, he told us a number of very important things that we should remember to avoid such cases in the future, namely:
- Remember that: Anything that can go wrong will go wrong - Murphy’s Law
- Remember that we won’t be judged for our mistakes
- Make sure that we understand exactly what happened
- Make fixes very carefully to not cause other issues
- Document our failures and solutions for them
- Share the information about failures with others
This last tip is very important. We should always share our failures with team members ASAP!
Let’s imagine a sample failure scenario where all developers are able to deploy an app.
Problem: Something has been changed with the deployment configuration and it wasn’t described carefully.
A developer, John, comes to work and decides to deploy his finished tasks. As always, he follows the deployment guide, builds the app, and successfully deploys his changes. After a few minutes he realizes that production is not working at all. John asks his teammate why this has happened and what the root of the problem is. It takes around 20-30 minutes for John to learn what has been changed, update his deploy config, build the app again and deploy the changes once again. John solves the issue, but the production system wasn’t working for around 30 minutes. John decides to update the team deployment guide to avoid this issue in the future.
In the afternoon, another developer, James, decides to deploy his finished tasks. He doesn’t look at the deployment guide, because he already knows the flow very well. Unfortunately the same issue happens to James and production is down the same day once again.
Summary: If John had shared the information about the failure with a team notification (instead of only updating the guide), then James would not have the same problem.
See you next year!
Discussions from the conference on our internal channels have been continuing for weeks after the conference. The Ruby vs Elixir debate is still raging - giving us prime popcorn conversation for perhaps a whole year 🍚
P.S. There was also no shortage of conference swag - we left with nerd socks in rubies 😃 Courtesy of Monika 😋