Ylan Segal

Ruby Implicit `to_proc`

Ruby’s blocks are one of the language features I like the most. The make iterating on collections extremely easy.

1
2
[1, 2, 3].map { |n| n.to_s }
=> ["1", "2", "3"]

You can shorten the (already short!) syntax above, like so:

1
2
[1, 2, 3].map &:to_s
=> ["1", "2", "3"]

The above is implicitly calling to_proc on the symbol. This es extremely handy, when you are calling the same method on each object. However, it can also be useful to call a method with each object as an argument:

1
2
3
4
5
6
7
def fancy_formatvalue)
 "==::[[#{value}]]::=="
end

['1', '3', 'a'].map &method(:fancy_format)

=> ["==::[[1]]::==", "==::[[3]]::==", "==::[[a]]::=="]

In addition, note that the number of arguments yielded to the method, depends on what the original implementation is. For hashes, this is especially useful:

1
2
3
4
5
6
7
8
9
10
11
def fancy_format(key, value)
  puts "==::[[#{key} - #{value}]]::=="
end

ball = { color: 'red', size: 'large', type: 'bouncy' }


>> ball.each &method(:fancy_format)
==::[[color - red]]::==
==::[[size - large]]::==
==::[[type - bouncy]]::==

Book Review: The Agile Culture - Pixton, Gibson & Nickolaisen

Pollyanna Pixton, Paul Gibson and Niel Nickolaisen write a concise and practical book on how to foster an Agile culture inside your company. It is geared towards those responsible for leading teams of software developers and other IT professionals, although most of the material is applicable to any leader.

Agile, at its roots, is about delivering software that brings value to the company and ultimately to the customer. In order to achieve this, it proposes short iterations and embracing change. The authors thesis is centered around trust and ownership. Trust from the leader to the team to do their job professionally. Ownership by the team of the product they work on. If both are present, the team will flourish. Leadership is about giving your team the tools to do their work and protecting them, not about meticulous control. Innovation comes from a culture where risk can be taken and failures can be learned from, as opposed to fear of being blamed and possibly fired. In a way, a lot of what the authors talk about is about aligning incentives of each individual to those of the organization. Of course, clarifying the organization goals and priorities and communicating those to it’s members is required.

The book reads very easily and is reach with anecdotes that illustrate good and bad leadership alike. The advice is sensible and not at all process-heavy like some other so-called ‘Agile’ books that have meticulous schedules for stand-ups, backlog pruning, retrospectives, etc. The advise feels also real-wordly: For example, it recognizes that not everyone in your organization may embrace Agile and gives you tools to deal with difficult employees and managers.

If you are a team leader, there is a lot to learn from this book.

Links:

The REPL: Issue 2

The Little Mocker

Uncle Bob writes about mocks, stubs, doubles, spies, etc. He explains the differences between them, how and when to use them. The examples are in Java, but are easily followed even with vague familiarity with the languge.

Back To Basics: Regular Expressions

The fellows at thoughbot give a great primer on regular expressions in ruby. The examples are easy to follow and yet manage to explain a lot of more advanced concepts like capture groups, expression modifiers and lookarounds.

Goto Fail, Heartbleed, and Unit Testing Culture

Back when Apple’s Goto Fail bug was news, my reaction to this was: How did the introduction of this bug pass the tests. At the time I thought about writing a test suite around it and running it with and without the duplicated line that causes the bug to demonstrate how test catch regression mistakes. I never got around to it, mainly because of my lack of familiarity with the language. Martin Fowler has written a lengthy and thoughtful post that expressess the feeling much better than I would have. It gives the same treatment to the [Heartbleed Bug] and explains why testing is so important in softare development.

I am lucky to work mainly in ruby, a community that is very test-oriented, even after the recent hoopla.

Unicorn vs. Puma: Round 3

MRI Ruby has gotten a lot faster since I ran my last benchmark, so it’s time for an update.

Methodology

The benchmark consists of hitting a single endpoint on a rails (4.1.1) app in production mode for 30 seconds. The endpoint reads a set amount of posts from a Postgres database and the renders them in a html view using erb, without any view caching.

The purpose of the benchmark to get an idea of the performances characteristics under varying load for MRI and jRuby. Unicorn was chosen for MRI because it uses the unix fork model for it’s processes, which is pretty much the de facto way to do concurrency in MRI. Puma was chosen for jRuby because it bills itself as a very efficient threading server (although recent versions can mix forking workers and threading). Threading is the de facto way to do concurrency on the JVM.

Of course, there are many parameters that can be tweaked in the server configuration. No benchmark is perfect, but I believe it’s a good indication of what type of performace differences can be seen in the two versions on ruby.

Here are the details:

Unicorn

  • Unicorn 4.8.3
  • Ruby 2.1.2
  • Configuration: 4 Workers, Timeout 30 seconds
  • Maximum observer memory usage: 450 Mb

Puma

  • Puma 2.8.2
  • jRuby 1.7.12
  • Configuration: Default configuraration (Maximum 16 threads)
  • Maximum observer memory usage: 482 Mb

The number of unicorn workers where used in order to match the amount of memory used by puma. In both cases, the observer memory stays below a 1x dyno from Heroku (but not by much).

The benchamrk was run with Apache’s Benchamrking Tool, with varying levels of concurrency:

1
$ ab -c $USER_COUNT -t 30 $URL

Results

Both servers perform similarly in the number of request they can handle per second. Unicorn seems to ramp up on par with it’s number of workers and then plateau. Even though more users are hitting the endpoint concurrently, unicorn just handles 4 at a time. Puma seems to increase in capacity with more users, although there is a sharp drop-off 1 at the end when reaching 64 concurrent users.

With regards of average (or 50th percentile) response time, it looks like both servers, surprisingly, perform exactly the same!. The response times are significantly slower when the server is under heavier load, but still perform acceptably.

The 95th percentile and 99th percentile graphs paint a different story though: Unicorn’s response time start to get more pronounced as concurrency increases, wich means that for some of the users, it might easily fall into unacceptable levels.

How significant is this? For example, let’s take the 32 concurrent users case: Puma 50th percentile response is 62 ms against unicorn’s 64 ms. Not very different. However, when we look at the 95% percentile puma comes in at 147 ms, wich is 2.3 times the average. Unicorn comes in at 175 ms, 2.7 times the average. Looking into the 99th percentile, puma’s response if 2.69 times the average response; Unicorn is a more dramatic 4.15 times. You should care about percentiles and not just the average response time.

Conclusion

Since the benchmark was last made, MRI Ruby has gotten much faster (last version was running in 1.9.3), however running a Rails app in jRuby still offers some performance characteristics under high load.


  1. I do not know what that drop-off means, and it didn’t seem to be there last year. However, I re-ran the benchmark many times, and got consistent results.

The Illusion of Security

I recently refinanced my car loan with a local credit union. The refinance process is pretty easy and mostly handled over the phone, until it’s time to sign the paperwork, for which they requested an email address. A few minutes later I get an email from the credit union in which I am notified that I have a secure email waiting at the other side of a link. Upon clicking, you visit a Barracuda Network site, in which I a need an email and password to access. As I have not established a password in the past, I just need to type a new one and confirm it in another box. Easy.