Ruby Tuesday

Issue #19

Tue, 28 Jan 2020 02:00:00 +0100

Remember Sorbet? It gained a lot of attention last year, but was kind of forgotten quickly. Especially now that built-in type ckecking for Ruby is promised in 3.0, its future is unknown. However, if you’d like to know more about the meat, read an article explaining why Sorbet typechecking is fast. It’s a good technical read.
For those who like very technical articles, here’s a piece about Ruby’s JIT and how it can be better/different. It’s called MIR: A lightweight JIT compiler project and contains quite a lot of knowledge about language design and implementation.
Another one in language implementation department is about Evaluating Ruby in Ruby by Ilya Bylich.
Machine learning and related topics are dominated by Python, C++ and Java. But it does not mean that we can’t have it in Ruby too! Andrew Kane spent a lot 5 months making 16 ML tools available for Ruby. They are usually just wrappers on C/C++ libraries, but the possibility to use them right from your ruby code is pretty cool. Read more here.
Here’s one from 2010, but still very interesting: Maze Generation: Eller’s Algorithm. You’d probably hate me but… it’s about generating mazes using Eller’s algorithm ¯_(ツ)_/¯ And the code is in Ruby, so it should be easier to wrap your head around it (it was for me).
And a news from today: if you care about code coverage, you have probably heard about SimpleCov. With its latest realease it adds branch coverage. So you will no longer easily get away with false ? 1 : 0-like code.

Issue #18

Tue, 17 Dec 2019 02:00:00 +0100

Hey! It’s been a while, but we’re back. Here are some interesting bits that happend in off Rails world lately:

Eventide 2.0 has been released. If you haven’t heard about it yet, it’s a collection of libraries implementing event sourcing, CQRS and Pub/Sub for Ruby. It is fairly complex and documentation is still missing a straightforward tutorial, but it’s worth looking at and knowing that it’s actively developed.
If you think the world is missing yet another static website generator, you might take a look at Clayoven. It has been developed mostly by one person over the course of 7 years and presents some interesting approaches (for one, it’s much less blog-focused, which really speak to me).
Also in department of one-person-awesome-projects, there is Midinous. It’s interesting, because it’s a GUI project, which is quite rare in Ruby world, and it’s about generating music, which aside from Sonic Pi, is also quite unique topic.
If you are worried about Ruby future, like me, you may also read a rant-ish post from Bozhidar Batsov, creator of Rubocop. He expresses his doubts in Ruby, Where do We Go Now?. There is also an interesting discussion on Reddit.
If you want to impress your fellow senior Ruby developers, try those Ruby Literals You May Not Know from Michael Kohl.

That’s it for today. And see you, hopefully soon!

Issue #17

Tue, 19 Mar 2019 02:00:00 +0100

Jekyll, a blog-aware static site generator, is approaching version 4.0.0. Alpha release is available now and it addresses one of the most painful part of Jekyll: slow render times with many pages. Ruby Tuesday webpage is powered by Jekyll, by the way. Jekyll 4.0.0.pre.alpha1 since today.
It’s still several months left unitl the release of Ruby 2.7, but we already have one cool feature merged: shorthand syntax for accessing parameters in block a.k.a. numbered parameters This feels to be taken straight from Elixir but it works well there and I think it should work well in ruby too, unless people abuse it. So, goodbye array.map { |elem| my_transformation(elem) }, hello array.map { my_transformation(@1) }!
Before Amazon started supporting Ruby in its Lambda serverless framework we already had a solution for Ruby: faastRuby. It has not been formotten and is still in active development. Recently, it introduced local environment to test you functions, which should facilitate development a lot.
If you are an “old” Ruby developer, you might remember Why The Lucky Stiff - “a Ruby artist” as some called him and author of the book “Why’s (poignant) Guide to Ruby”. He went off the grid after someone revealed his identity in 2009. Ten years later, a documentary about his legacy has been published.

Issue #16

Tue, 05 Mar 2019 02:00:00 +0100

Ruby can be weird. Don’t take my word for it. Instead, read this cool post called, well, Weird Ruby. A have already knew quite the few of things listed there, but still some blew my mind.
Moving from Ruby to Rust is… Wait. Am I including a post about abandoning Ruby in a Ruby newsletter?! Kind of. But I prefer to see this post as an introduction to offloading your performance-critical code to a better performing language (Rust in this case) and call it from you Ruby code. Unlike many similar intruductory posts, Deliveroo actually did it in production and share their experience.
dry-validation is one of most recognizable project from dry-rb team. It is going through quite a rewrite at the moment. Another gem, dry-schema, has been extracted from it and new dry-validation was written on top of it. Now it’s almost ready. Alpha version is released and you are welcome to test it.

Issue #15

Tue, 15 Jan 2019 02:00:00 +0100

It has already been some time, but I cannot not mention it. Ruby 2.6 has been released on Christmas. And one very serious bug with Net::Protocol has already been found.
Speaking of bugs, do you know how to crash Ruby 2.5 virtual machine in very few lines of code? Paweł Pacana certainly knows. It’s as simple as those six lines of code:

def doh
  raise
ensure
  123 if false
end
doh

Back to the good things. I have two concurrency-related posts for you:
- First one is about Task monad, coming from excellent dry-monads gem. I never knew such solution existed there. A very interested read.
- Second presents more traditional, yet frequently overlooked, approach: Fibers Are the Right Solution.
Law of Demeter, one on the foundations of SOLID principles, is a very misunderstood one. Many people treat it just as “counting dots” in your code. And they couldn’t be more wrong. Rebased takes you on the tour about LoD in Ruby, using Sinatra application as the example.

Happy coding in 2019!

Issue #14

Tue, 23 Oct 2018 03:00:00 +0200

Welcome after the summer break!

Good time are coming for Ruby on serverless infrastructure. In September support for Ruby on Apache OpenWhisk was announced. But we already have another option: FaaStRuby. It’s a platform designed specifically for Ruby language, it’s still young, but growing fast. For example, last weekend a support for cron-like jobs was added – something that is missing in even more mature platforms, such as OpenFaaS.
If you really hate JavaScript and love Ruby, you can use the latter for writing frontend too! There is a project called Hyperstack that allows you to write frontend applications using quite ugly Ruby DSL. It is then compiled via Opal to some ReactJS, powered by Webpack. The stack looks pretty good. And it’s recommended to use FaaStRuby to perform some backend tasks, having full serverless webapps written in Ruby.
However, if you are still into plain old code-writing, you can keep an eye at dry-behaviour project. It aims at bringing the power of Elixir protocols to Ruby and looks interesting. It’s not officially part of dry-rb though (don’t get mislead by its name).
Another feature pulled from other languages is destructuring. This blog post provides a detailed description on how to have it in Ruby and why it can be cool. Even if destructuring is not you favourite flavour, it’s worth checking out.
For a (not too) deep dive into Ruby internals, read Statements and Expressions in Ruby and learn what’s the difference between those two and what consequencec it has.

Issue #13

Tue, 17 Jul 2018 03:00:00 +0200

This time I want to start with two posts I wrote in the meantime:

Hidden gems of Ruby stdlib explores less-known feature and classes Ruby is shipped with. I don’t know if you’ll ever need them, but it’s at least good to know that they are there, ready to be picked. And by the way, some people are actually using those.
Notes on writing Service Objects is a summary of practices I try to follow when writing SOs - most popular Ruby refactoring technique right now. Since there is no formal definition of them, I think it’s a good way to establish some boundaries and rules about how they should look.

But let’s not talk about me. There are other things worth noticing lately.

Http.rb is Great might be yet another comparisoon of what you can use to perform HTTP requests in Ruby, but it’s a very good one. Even though the title contains spoiler.
Joe Leo at GORUCO conference had a very good lightning talk (?) about how to write Ruby in 2018 and why we should all be excited of what is to come. Watch it here.
If you still want to look into Ruby internals, check out a blog post about Forwardable module.
Remeber TruffleRuby? Yes, the one that promised high speed and working with all popular C extenstions. Now you can install it via RVM, Rbenv or other version managers for Ruby. So, no more excuses not to try it!
I think some of us might have seen live music coding session by Nicolas Dermine in Sonic Pi. If you haven’t - check this out. But if you want a gentle textual introduction to Sonic Pi, here’s a nice blog post on Twillio blog.

Issue #12

Tue, 05 Jun 2018 03:00:00 +0200

Welcome back after a longer break! I feel like much less things were happening in Ruby in recent weeks and there was not enough material to share here. And since I don’t want to force frequent issues over the quality, I decided to wait until the content queue fills up.

Let’s start with two posts from Janko Marohnić:

First one is quite old and it is a introductory post about ImageProcessing – his library to, well, process images. It reached 1.0 in April and Janko shares why he created it and how it’s different/better than existing solutions.
More recent post is a roundup of existing HTTP client libraries with some comparisons and a compelling analysis why http.rb is (maybe) the best of them.

Other things:

You probably have heard about guilds coming in Ruby 3. Today first code was revealed in one of the forks, owned by Koichi Sasada. Here is a comparison against master. Be warned though that it’s C code and understanding it is not necessarily easy.
Stripe is building a Ruby typechecker. This is actually a big news as many people think that some level of typechecking is necessary in larger codebases. This solution, called Sorbet, is written in C++, is quite fast (they are talking 100k lines per second) and is something like TypeScript for JavaScript. For now you can try it out online but nothing more has been revealed so far.
Luca Guidi wrote a pretty cool post about implementing async map/reduce queue in pure Ruby. I’m especially fond of it because I lately started to think that we rely too much on external tools (such as Sidekiq for any kind of asynchronous things) when chances are we could easily write something better-suited ourselves.

My small contibution:

I reviewed Pagy – “the ultimate pagination ruby gem” – which made all the news some time ago. More precisely, I tried to integrate it with Hanami and find answer to a question: it it really as ORM-agnostic and as working-with-any-framework as advertised?

Thanks for reading!

Issue #11

Tue, 03 Apr 2018 03:00:00 +0200

```
start = Time.now
heavy_operation()
time_taken = Time.now - start
```
Have you ever written a code like that? I most certainly did. Turns out it’s all wrong. Why and how to make it better? Read and explanation by Luca Guidi, author of Hanami framework.
Integer overflow is sooooo C, right? What if I told you it could affect Ruby and was fixed only recently? Read the whole story here.
Rack::Reducer is a new gem to help you write queries with filters from query params applied. Designed for ActiveRecord, it can also be user with Sequel, Hanami, ROM etc. Here’s an introductory blog post about it.
If you need to maintain communication between couple of microservices, chances are you’d use HTTP. And probably it’s not the best choice. There are many tools better fit for the job. One of them is gRPC from Google, based on Protocol Buffers. Here’s a tutorial on how to use it with Ruby.
Wanna use value objects? (They told us that it’s a very first step towards DDD.) You may want to read a crowdsourced list of best practices when doing so.
Bradley Schaefer talks about an antipatter we didn’t even know exists. But it’s there: The Local Variable Aversion Antipattern.

Issue #10

Tue, 20 Mar 2018 02:00:00 +0100

Hello! This issue will be dominated by the fact that last weekend I attended awesome wroc_love.rb conference. Besides listening to some really good talks, I also learned (or was reminded) about a couple of really cool gems I want to share with you:

Eventide – it is a complete solution for Event Sourcing in Ruby, supporting Event Store and PostgreSQL as backend
We all know about ActionCable in Rails, most of us also know that AnyCable is soooo much better for the task. However, what I did not know that there is a compatible replacement for non-Rails Rack applications called LiteCable. So, all your Hanami-, Sinatra-, dry-web- and what-not-based app can have it.
Plezi is another, quite different, option for having Ruby-powered websocket-heavy application. It’s not a web framework per se, just for real time.
Plezi is based on Iodine – a webserver for HTTP and WebSockets, heavily optimized for running on Linux.
oop-interface – interfaces were kind of a holy grail for years in Ruby world (similar to pattern matching lately). This is another attempt to make something similar. At first look I don’t like it much, but maybe someone will find it more useful.
Interface gem is not new. It has been around for some time and I knew it. However I never dug deep enough to find out that is has a thing called “Organizers” to make more complex workflows with interactors and has ability to define a rollback function for them. Sounds very cool.
Nihilist is a gem with convenience structure for null objects. However, it is so simple that you might be better off with just copying into your codebase, instead of including a gem.
Heapy – a gem for inspecting Ruby heap dumps. Very useful when you’re trying to track some memory leak.

Also, not a gem, but spotted at the conference, there is a Gem Check project, that aims at providing a checklist for gem authors on how to make your library as good as possible. This is a really good effort and in case you author some gems, you need to at least read it.