blog of Marian Posăceanu - rubyist most of the time

PRs are dead, long live PRs?

2026-08-06T09:31:05Z

Pull requests are an important part of programming culture. They serve multiple purposes and vary across teams, organisations and even technologies. In essence, they reflect how a team constantly evolves, both through its individual members and its code.

They can be used to teach, fix bugs, refactor code, spark new ideas and even make friends through open source.

The question is: how will they evolve in the age of LLMs? It's trivial to create a PR now and even review it. With models like Sol working alongside a senior developer, the whole process can be semi-automated and still result in well-reviewed, high-quality code.

But what about the other aspects surrounding a PR? What about teaching, knowledge transfer, the social aspect, the culture which they help to build?

All of that seems to be gone to some degree when someone opens a PR with 10K+ LoC of changes. It seems PRs will become artefacts of a bygone era.

The way forward is not clear. How do we keep the culture around PRs? How do we keep the human aspect? It will all live in "/agents/*", in Markdown files which slowly evolve.

It seems our culture will live on in Markdown artefacts, at least for now. The PR and its humanity will depend on how much of it is produced by an LLM and how much by the team itself.

We now have to make an effort to stay human because we might lose the culture around these artefacts if we fully replace them with LLM workflows.

How are we going to transfer knowledge, share idioms and help other developers grow if the PR is dead? I remember getting comments on my PRs more than a decade ago, looking up what they meant and reading articles and books just to get better at the craft. That shaped and enlightened me. I would not be the developer I am today without the feedback, the idioms and the culture that PRs helped foster.

Sources

https://x.com/charliermarsh/status/2085154924564709465?s=20

The half-life of a programmer

2025-07-05T21:20:05Z

I had this almost random idea of when a programmer hits his or her career half-life.

Tangents

First a few points that need explaining: almost random is in the sense that this time next year I'll be hitting thirty (Faith No More track is already playing in my head).

The next point is how one should understand the word "career" in the context of the field I'm working in. The word itself makes me think of a reductionist, fifties-like view of how one works and/or deals with work.

This begets the question "What does 'career' mean for a programmer?" - tricky question and interesting tangent: methinks it refers to that period of time when one starts to work professionally (getting paid) to the point in time when one stops doing that.

Let's jump on another tangent: "Why is the end of a programming career when one stops writing code?" - clearly one could easily jump on a management position and still call oneself a programmer - that for me is not programming any more, maybe I'm a purist and yes I'm not fond of labels like "team leader", "CTO", "lead developer", "senior developer" and all that paraphernalia that in the end is just utter nonsense.

Relation to age

If one looks around the "average" age or more likely the anecdotal age (yes this is not even proper empirical data) of developers in shiny start-ups is around twenty-seven, I reckon. And it makes sense - they're relatively fresh out of university programmers with a decent experience on that hi(y)ppie new programming language or paradigm.

I don't want to turn this into a rant, methinks I was also in that situation and it's a sane approach as long as one doesn't go into extremes (like using MongoDB, OrientDB, InfluxDB, etc. for a problem domain where a relational DB is eye-meltingly clear).

In any case, years pass, one gets experience and more importantly, experience at a higher level i.e. when one can much more easily understand the inner workings of complex systems. The problem that stems out of this is that at some point work gets repetitive (if you let it) and one can easily get entrenched in a tool-chain.

The half-life of a programmer

I'm starting to feel this is the crux of the problem: a programmer hits half-life when he realizes that most of the work he does is repetitive and he or she gets entrenched in a tool-chain. Clearly, if one cannot overcome these slight issues then we have a problem that might lead to a non-programming career or an illusory one: "team leader", "CTO", "lead developer", "senior developer", "consultant" etc.

The issue with those terms is that some programmers start to take it way too seriously whilst completely ignoring what I like to call referential humility.

Most of my heroes: the likes of Jim Weirich , Sandi Metz and more seem to be in for life (the career) and I find that very reassuring.

Referential humility

What does that mean in the end? - just a play of words from referential integrity:

Referential integrity is a property of data which, when satisfied, requires every value of one attribute (column) of a relation (table) to exist as a value of another attribute in a different (or the same) relation (table).

In other words: there's always something "new" or something we still don't have a grasp of - hence the end of the road in a programmer's career is virtually non-existent.

Conclusion

Once you hit this half-life - choose wisely, work in the end is just another distraction from death, it's in our best interest to make that distraction authentic.

Vaguely related to the distraction from death tangent:

Using Firebug as a scalpel, yet not for web development

2025-07-05T21:20:05Z

Needless to say, I’m an avid user of Firebug , let’s face it: without it, web development would suck big time, yes we do have other variants but firebug remains the status quo, for me at least. Yet this is not an article about how to develop web apps with Firebug, no, it is an article about how one can use it to have a little fun and be more practical.

Everyone hates ads, well maybe hate is a bit too much, everyone dislikes ads, I know I do. In Firefox we have the AdBlock Plus extension. Does the job pretty nicely, yet nicely, doesn’t fit my taste, why, you may ask? Well firstly, it’s not that fast and breaks my development by taking me out of the flow (it does that by making Firefox and the pages I visit slow - this is an empirical observation, it’s been a while since I’ve used the extension) and secondly because

on some sites I actually want to see the ads and maybe even click the darn things so I can show my support

(and that’s a big chunk of the sites I visit daily).

Going back on track: today we use web apps for a considerable time: I open ad-supported web apps in the browser and keep them opened for the entire session (since I rarely close Firefox, that could mean a full day, or even more - I use hibernate). What don’t I like about them? The ads of course, now this may come in conflict with the previous paragraph but I’ve got a good reason for killing them ads: most of the time they’re flash and they change at intervals of time, problem with that and Firefox in long sessions is that it leaks memory like crazy (it’s something related to the extensions, I reckon) and Flash and those ads seem to help a lot.

By now, it’s pretty obvious: I kill them with Firebug. How? Pretty easily, first, I find the node, the container for the iframes or whatever they use, and delete that node using Firebug since the node doesn’t exist anymore, gone are the ads. One may ask “But you do this every time? Why don’t you use an extension like greasemonkey or something to do that for you ?” My answer: I have long sessions and I only do that for 1-2 sites that I keep opened all the time so it doesn’t bother me, also using Greasemonkey or something similar would add up to the resources that Firefox is using, probably getting me somewhere near the ad-block version.

In conclusion, Firebug can be useful for something else than web development.

References

Firebug - what I use
AdBlock Plus - what I used to use
Greasemonkey - what I need to test some more

Tomorrow is the first day of How to web 2010, this should be fun

2025-07-05T21:20:05Z

Just got to Bucharest, tomorrow I’ll be at How to Web 2010 . Hope it’s going to be good, the presentations look juicy.

I hope I’ll meet some inspiring people and hopefully something to burst some new ideas or perspectives about the web. All in all, it’s not such a simple subject like: "oh, so you do web stuff ? isn’t that nice", the whole area is getting more and more complex by the day.

That’s not a bad thing of course, the problem is coping with all that change coming in small bits at high speed. Let’s look at this problem from a programmer’s perspective, firstly we have the basic stuff, algorithms, patterns, good problem solving skills, testing and all that, but new technologies emerge at a fast pace. How can we cope with all that change ?

“oh, so you do web stuff ? isn’t that nice and simple...”

Some time ago I was thinking that having a good/great understanding of the basics would suffice, well experience has proved me wrong. Yes, basics and everything I’ve enumerated are very important, but to actually be able to work in this environment you must be up to date (of course I’m not saying you should know all the HTML5 unfinished specifications, that’s just plain over-voltage).

Returning to the subject, conferences like this are good, they catch all those new emerging ideas and spread them in big chunks at a small speed so we can get a picture of the whole thing, it’s like a snapshot of the state of the web (too much ?); well the next conference is going to be more specific.

Reference

How to Web - conference link

The inherent entropy in our lives: to resist or to...

2025-07-05T21:20:05Z

I’ve started thinking about it after I read this article and this tweet got me going for a couple of days: “My whole life I’ve been fighting entropy, maybe it’s time I stop fighting” by @stevenbristol . I love stuff like this; it makes me ponder on what would be the best way one could choose and what would the solution imply, let’s say, in an empirical way.

Firstly, one must define entropy, so here’s my cherry picked definition:

“entropy is a measure of the uncertainty associated with a random variable.”

Of course there are more, but I like this one because it works almost flawlessly as a metaphor for life itself: that random variable = life, entropy being the hazard (one should take this with a grain of whatever he/she likes, it’s merely a reductionist definition for the purpose of this article).

So let’s see... at the surface I see two possible solutions: to fight entropy (not necessarily fight it but more in a way of how a sailor doesn’t fight the storm, he embraces the flow of the waves and the wind so he can make it safely to the other side) or to go with it. I just realized that I’ve been fighting entropy in a bad way, I’m always trying to apply structure to my life and to everything that I do, like work, yet most of the time something like "random(life)" happens and all that abstract structure that exists in my head goes away in a blink of an eye.

There’s nothing wrong with having structures in your life, it’s a good thing, but one (especially me) must realize that it doesn’t always work out and high expectations go hand in hand with high delusions and the latter ones hurt like hell. Going back to my point: one must embrace the flow of entropy, yet with a small nuance, not in a deterministic way, I mean, not in the way of letting our lives be driven by sheer randomness of events (that’s actually the second solution: to go with it), that’s bad. I find it hard to define it.

Why is it bad to go with entropy, to embrace it and let one’s life be driven by it? It’s pretty obvious, I think: we lose all little control we have on our lives. It’s clear we cannot be in full control of external things, yet at least we can be in full control of how we react to entropy (I think that’s the key I needed for the previous paragraph).

The solution: one must learn to be in control of his/her reactions to entropy. How do we do that ? It varies from person to person, one might code an app for that or someone else (like me) might just realize this and try to apply it from now on.

In the end, I wish you all the best and a Merry Christmas.

References

1 - wiki definition
Fight Entropy! Keep Moving Forward! - nice article
@stevenbristol - he started it all !

The frontend backend debacle

2025-07-05T21:20:05Z

I’m really starting to get fed up with this useless separation. (Warning: strong personal opinions, based on arguments following).

Ok, it’s not useless, I get the idea in a big team, separation of concerns, better productivity and all that. That’s good and I’m all for that, makes things faster (in the big picture at least). Anyway, what I don’t get is why people who do programming need to bracket themselves into this kind of namespacing.

Whether you’re programming in JavaScript, PHP, Ruby, or Java or even LOL-code in the end you are still a programmer. If you think that calling yourself a frontend, backend or middle-end developer makes you somehow better, I’ve got news for you: it doesn’t.

“It just shows that you can’t actually handle programming in a true sense”

I’m not saying being a js developer is easy, no way! Actually starting to learn the concepts behind js made me a better programmer and helped me get into more advanced stuff like Ruby or Clojure. Yes, we have the DOM model and all that stuff, but really, one can abstract that using a library and still write advanced UIs with little or no performance problems. And don’t get me started on html and css, anyone can learn that, if you can write a hello world java program then, my friend, CSS and HTML are a piece of cake.

Baseline ? A true programmer should be able to code in almost any language. If in your team you work as a backender or frontender, that’s ok, but that doesn’t mean you should not know css, html or js or vice-versa, other programming languages and concepts.

You must know the basics and stay up to date, yes it’s not easy, so deal with it and let’s stop hiding behind name spaces ok ?

Shedding some light into UUID version 4 in Ruby and Rails

2025-07-05T21:20:05Z

Ruby's standard library and Rails's PostgreSQL adapter use by default version 4 UUIDs. This could be changed in Rails migrations via:

default: 'uuid_generate_v1()'

parameter, whereas Ruby's stdlib only supports version 4.

Another interesting difference is in the implementations:

In Ruby's stdlib, the UUID method is found in `SecureRandom`:

  # SecureRandom.uuid generates a random v4 UUID (Universally Unique IDentifier).
  #
  # The version 4 UUID is purely random (except the version).
  # It doesn't contain meaningful information such as MAC addresses, timestamps, etc.
  #
  # See RFC 4122 for details of UUID.
  #
  def uuid
    ary = random_bytes(16).unpack("NnnnnN")
    ary[2] = (ary[2] & 0x0fff) | 0x4000
    ary[3] = (ary[3] & 0x3fff) | 0x8000
    "%08x-%04x-%04x-%04x-%04x%08x" % ary
  end

source-code

The Rails version uses the `uuid-ossp` PostgreSQL extension:

  # By default, this will use the +uuid_generate_v4()+ function from the
  # +uuid-ossp+ extension, which MUST be enabled on your database.
  def primary_key(name, type = :primary_key, options = {})
    return super unless type == :uuid
    options[:default] = options.fetch(:default, 'uuid_generate_v4()')
    options[:primary_key] = true
    column name, type, options
  end

source-code

The difference examined here is how the random bits are generated in each library - this is quite interesting to investigate - let's start with the Ruby stdlib.

Ruby standard library implementation

module SecureRandom
  if defined? OpenSSL::Random
    def self.gen_random(n)
      @pid = 0 unless defined?(@pid)
      pid = $$
      unless @pid == pid
        now = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
        ary = [now, @pid, pid]
        OpenSSL::Random.random_add(ary.join("").to_s, 0.0)
        @pid = pid
      end
      return OpenSSL::Random.random_bytes(n)
    end
  else
    def self.gen_random(n)
      ret = Random.raw_seed(n)
      unless ret
        raise NotImplementedError, "No random device"
      end
      unless ret.length == n
        raise NotImplementedError, "Unexpected partial read from random device: only #{ret.length} for #{n} bytes"
      end
      ret
    end
  end
end

source-code

It starts with OpenSSL::Random which can be described as:

OpenSSL cannot generate truly random numbers directly. The choices are to use a cryptographically secure PRNG with a good random seed (i.e. with OS harvested data from effectively random hardware events); or use a real hardware RNG. [1]

If OpenSSL is not present it falls back to Ruby's pseudo-random number generator implemented in Random.raw_seed which uses a modified Mersenne Twister with a period of 2**19937 - 1.

uuid-ossp extension implementation

Looking at uuid-ossp source-code we can find:

Datum
uuid_generate_v4(PG_FUNCTION_ARGS)
{
  return uuid_generate_internal(UUID_MAKE_V4, NULL, NULL, 0);
}

and the uuid_generate_internal relevant part of the function:

case 4:         /* random uuid */
default:
{
  #ifdef HAVE_UUID_E2FS
    uuid_t      uu;
    uuid_generate_random(uu);
    uuid_unparse(uu, strbuf);
  #endif
   break;
}

As we can see there's a call to uuid_generate_random - what is it?

uuid_generate_random(3) - Linux man page

Its description:

The uuid_generate_random function forces the use of the all-random UUID format, even if a high-quality random number generator (i.e., /dev/urandom) is not available, in which case a pseudo-random generator will be substituted. Note that the use of a pseudo-random generator may compromise the uniqueness of UUIDs generated in this fashion.

Interesting to note that if /dev/urandom is not available - again it falls back to a PRNG. It seems there's a nuance here or even a contradiction as /dev/urandom uses csPRNG (cryptographically secure pseudorandom number generator) [3]

Conclusions

This started as a simple curiosity on what versions of UUID I could use - note that this is not a critique of truly random vs. PRNGs as the RFC clearly states:

The version 4 UUID is meant for generating UUIDs from truly-random or pseudo-random numbers. [0]

which makes both implementations correct.

It makes sense for the UUID method to be in SecureRandom in Ruby since it's only the version 4 implementation and by default it uses OpenSSL::Random. The only minor gripe I have with this is that there's no UUID lib for general use in Ruby supporting all the versions [2].

Regarding their implementations it should be noted that they differ and if the quality of randomness is important one should further investigate (e.g. due to missing OpenSSL - Ruby will use the internal PRNG which at first look appears quite solid as it uses for seeding dev/urandom [6] but it might not be in the same class of csPRNG)

For UUIDs both implementations should yield usable random UUIDs even if the library falls back to a non-CSPRNG algorithm. In the end there's a small gotcha:

Distributed applications generating UUIDs at a variety of hosts must be willing to rely on the random number source at all hosts. If this is not feasible, the namespace variant should be used.

In order to avoid UUID collisions [4].

References

[0] - RFC-4122 [1] - Why OpenSSL can't use /dev/random directly? question [2] - I usually use uuidtools [3] - Myths about /dev/urandom [4] - uuid-collisions [5] - bonus read GoodPracticeRNG [6] - source-code

Ruby 2.2.0 Preview 1 quick Rails benchmarks

2025-07-05T21:20:05Z

Great news everyone! Ruby 2.2 preview 1 has been released ! I'm really curious about the Incremental GC and Symbol GC so let's run some quick Rails benchmarks on a normal Rails API app.

First off let's install the preview via RVM:

rvm install ruby-2.2.0-preview1

After fiddling around for about five minutes trying to find a part of the application that doesn't fail under the Preview I stopped at the simple /profiles endpoint that just renders JSON for all profiles, quite simple indeed. Using the trusty wrk I fired up a quick bench:

wrk -t10 -c10 -d20s http://localhost:8080/profiles

The results are as follows:

Ruby 2.1.2p95

Running 20s test @ http://localhost:8080/profiles
  10 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   255.02ms   25.10ms 372.80ms   67.61%
    Req/Sec     3.21      0.70     5.00     71.13%
  771 requests in 20.01s, 4.40MB read
Requests/sec:     38.53
Transfer/sec:    225.31KB
------------------------------
50%,252 ms
90%,285 ms
99%,328 ms
99.999%,372 ms

Ruby 2.2.0preview1

Running 20s test @ http://localhost:8080/profiles
  10 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   253.27ms   30.64ms 344.75ms   64.21%
    Req/Sec     3.34      0.70     5.00     89.63%
  786 requests in 20.02s, 4.49MB read
Requests/sec:     39.26
Transfer/sec:    229.60KB
------------------------------
50%,251 ms
90%,291 ms
99%,329 ms
99.999%,344 ms

I'm not really sure that I should interpret them, yet it seems that under the Preview we have a slight improvement but within margins of error. At this point I don't think this is the best benchmark for the Preview as we don't use views thus Rails won't bloat up the memory with Strings.

On the memory usage side we have 65M vs 75M (Preview vs. 2.1) so in this scenario we clearly have a winner.

note: this was measured using OSX's Activity Monitor after wrk finished the benchmark and it's the average of the unicorn workers sizes.

Issues

Bundler and all the gems installed without issue but in some cases I got silent failures. The benchmarks were run on an actual working/production Rails 4.0.x app with around 25 gems. Nonetheless all of the gems installed and I could boot up Rails with unicorn and benchmark the simpler endpoints which is great.

Conclusion

TBD — this is a work in progress; I will update it with more information.

Programatica 2010 after thoughts

2025-07-05T21:20:05Z

Yes, I’ve attended one more conference Programatica 2010 , this one was axed on programming. It started with some interesting to not so interesting presentations of the partners. What I’ve loved about them, was that they contrasted with each other pretty nicely to a point when it was actually funny.

I’ve observed something interesting about the big names, like IBM, Microsoft and Oracle: they’re starting to converge their developer tools to open-source inspired models. How ? Well, let’s take their presentations one by one: Oracle ADF - this is an interesting framework for developing enterprise-class applications, from what I’ve seen is a set of extensions to JavaEE in the vein of the Spring Framework this is nice and all that but I don’t really like uber-complex IDEs (they might appear to save you time but you have to learn all the intricacies of how they work, also they might have bugs so my question is: Why spend time on finding solutions to the IDE bug when I could find solutions to the actual bugs in my application ?)

Next in line: IBM Jazz open-source platform that can integrate their well-known tools (like RUP) and all those nice pre-made processes for requirements, testing, developing, artifacts management and all that but with a nice open-source twist on them while also trying to make them flexible in an Agile way. The path here is obvious, again open-source is the root of the big change, it’s an adaptation.

And last but not least we have Microsoft with their Azure cloud platform (I kinda like it, should scale pretty well and it’s not that pricey compared to the rest, of course I haven’t tested it so all that might be just gibberish) - they support open-source development in SourceForge kind of way, all the community projects are hosted there - like PHP SDK for IIS.

On Azure you can pretty much run anything from java to ruby and of course their beloved .NET. The problem with it is that if you want to run a really small app, you don’t really have a plan for that (besides trials and a free limited to 25 machine hours version), they start at 59$ or something like that, but you get 20 instances which is nice for a big app, one might guess. Also nice, is that their platform is mostly complete and somehow on par with clouds like Rackspace or Heroku.

Ok, before finishing the post, I must write about Andrian Amariei ’s speech about how programmers tend to see things and sometimes the whole world in a restricted dualistic way: black or white, 1 or 0,

“We’re being held captive between the walls of our own mind”

The thing is that the real world is made of shades of grey and not absolute truths, we must keep that in mind and wake up !

On zygohistomorphic prepromorphisms

2025-07-05T21:20:05Z

There are words in programming that look like jokes. Zygohistomorphic prepromorphism is one of them.

The first time you encounter it, you assume one of two things must have happened. Either someone lost a bet, or category theorists were left unsupervised for too long. Both explanations feel plausible.

And yet the term survived. It appears in libraries. It appears on the Haskell wiki. People occasionally implement it, usually after an evening spent exploring recursion schemes and slowly realizing that the rabbit hole goes deeper than expected.

What is surprising is that behind the intimidating name there is actually a relatively simple idea. The difficulty is not the concept itself, but the number of layers you have to peel away before it becomes visible.

Recursion, but with memory

Most recursive programs share a common shape. You start with some structure, reduce it step by step, and eventually collapse it into a value. Lists become numbers, trees become summaries, syntax structures become evaluations.

In the functional programming world this pattern has a precise name: a catamorphism. In more familiar terms, it is simply a fold.

A fold walks over a structure and accumulates a result as it goes. It works for lists, trees, and many other recursive data types. The details change depending on the structure, but the pattern remains the same: descend into the structure, combine results on the way back up.

For many problems this is perfectly sufficient. But not all recursive computations are so cooperative.

Sometimes the recursive step needs more information than just the results of its children. It might need access to intermediate computations that happened earlier in the traversal. Or it might need to look at the structure in a slightly different form before the recursion even begins. Once those requirements appear, the simple fold starts to feel a little too simple.

Adding just one more layer

Programmers have a well-known habit when something almost works. They add one more layer.

A histomorphism extends a fold by annotating the recursive structure with results already computed for its substructures. Instead of seeing only the immediate results of recursive calls, the computation can access those annotated subresults. A zygomorphism allows two recursive computations to run together. One traversal produces information that the other one can consume, effectively letting two analyses cooperate as they walk the same structure. A prepromorphism adds another capability: it applies a natural transformation to the base functor at each recursive step before the algebra is evaluated. The structure is reshaped as recursion proceeds, rather than transformed once in advance.

Individually, each of these ideas solves a small limitation of a plain fold. They are incremental extensions that add a bit more context to the recursion. Combine them, however, and the name becomes a small monster:

zygo + histo + prepro + morphism

Which gives us the formidable zygohistomorphic prepromorphism. It sounds like something a doctor might diagnose. In practice, it is a deliberately composite recursion scheme combining a zygomorphism, a histomorphism, and a prepromorphism.

Why anyone would do this

At this point a reasonable question usually appears. Why not just write the recursion directly? Most of the time, that is exactly what you should do.

Recursion schemes are not about saving keystrokes. They are about separating concerns. Instead of intertwining traversal logic with the computation itself, they isolate the mechanics of walking a structure from the operations performed on that structure. Traversal becomes reusable. Computation becomes composable.

This separation becomes valuable when you begin running multiple analyses over the same recursive data structure, or when different transformations need to cooperate during traversal. In those cases the abstraction stops looking excessive and starts looking convenient.

Until you reach that point, though, the name alone can make it feel like something that escaped from a biology textbook.

The cost of names

Names matter more than we often admit. Some abstractions fail because they are genuinely too complex. Others fail because their names discourage anyone from getting close enough to understand them. Zygohistomorphic prepromorphism suffers a little from both.

The name compresses an entire lineage of ideas: zygomorphisms, histomorphisms, prepromorphisms. Each term has its own precise meaning within the taxonomy of recursion schemes. Combined, however, they form something that reads less like a programming concept and more like an academic prank. Which is unfortunate.

Because the underlying idea is actually quite gentle. Sometimes recursion needs memory. Sometimes it needs cooperation between multiple computations. Sometimes it needs a transformation before the recursion even starts. That is all the abstraction is trying to express.

A small observation

Programming languages accumulate complexity in two distinct ways. One kind of complexity comes from the problems we are trying to solve. Real-world systems are messy, and the abstractions we build inevitably reflect that messiness.

The other kind of complexity comes from the vocabulary we invent while trying to describe those abstractions. Occasionally the vocabulary grows faster than the underlying ideas. Zygohistomorphic prepromorphisms sit right at that boundary. They are both an elegant generalization of recursive structure traversal and a reminder that abstraction, if left unattended, tends to produce very long names.

Perhaps that is fitting. After all, the idea itself is not particularly complicated. Only the word is.

References and provenance

On writing artisanal code

2025-07-05T21:20:05Z

Every artisan at a certain point in time just stops and starts thinking about the inner workings of his craft. He ponders on the whole process from the outside while trying to make connections between apparently dissimilar entities that his craft is made of.

One might argue that this is a purely subjective endeavor: well, without any formal applicable theories it certainly is! Yet this doesn’t mean it cannot spark insights.

Coding is a very elusive mixture, it involves formal rules (the language), it can be mixed or even expressed via mathematical modeling and it’s also a first-class subjective practice. Coding is thus artisanal because we have the metaphor of shaping an abstracted real-world idea into another realm.

Code is ephemeral, it is driven by a set of semantics that must be transmitted. We can see it as a machine, yet one that must be plugged into another machine: the artisan himself, together they create meaning.

The issue with this is that meaning is hardly quantifiable: it depends on a transient object—the mind that interprets it thus code is an incomplete little machine.

The question rises: what characteristics of code have enough in common with all minds that can form plateaus of recognizable values? Well, if code conveys meaning, we want code that is expressive so that it is able to convey its creator’s semantics to any reader or to put it another way : we want to maximize the function of adherent readers.

OK, what makes code expressive ? Looking at its form we can have code that is verbose versus code that is succinct. How do we choose which one is better? We might say that it depends on the code but think about this: let’s say we have two versions of the same implementation of a solution to a problem, now, given that they have the same quotient of conveying meaning which one we choose ? The answer is clear: the succinct code but only when the quotient approaches the idealized value of one.

How do we maximize this quotient of conveying meaning? I’ll ponder some more on this.

“It helps to have a language that is like molding clay rather than carving stone.” - Paul Graham

On unnamed abstracts, entities and happiness

2025-07-05T21:20:05Z

When I look upon my day-to-day behavior the pattern that pops out is that of abstracted sets of ideas interchanging one another or making connections to other entities, bringing them in the foreground, into my field of subjectivity.

We try to make perception ours thus abstracting it away in nicely grouped entities that can relate to one another. I'm doing this daily e.g., when I open my browser and visit a webpage, what I'm actually doing is accessing an abstracted entity from my memory: a browser, a webpage, the Internet.

The issue here is that a subjective quotient comes into play that creates leaky abstractions. Reductionist views in which details dissolve without a trace, one could argue that by themselves abstractions can be viewed as a reductionist view of perception or better yet: semantic compression of streaming information.

We must draw a line between what a “good” abstraction would involve and a leaky one would dissolve. Seems like we have more questions than facts. Looking from another angle and replacing the "good" with the standard definition of utilitarianism:

Utilitarianism is a theory in normative ethics holding that the proper course of action is the one that maximizes utility, specifically defined as maximizing happiness and reducing suffering.

From this perspective a proper abstraction is one that maximizes utility (happiness could be a far product of this). Utility in the sense that while keeping semantic compression close to an ideal ratio our abstraction preserves its most important details; by contrast a leaky one would miss them which, in relationship with other entities, would cause wrong interpretations and thus unhappiness.

Getting back to reality: all abstractions are leaky, the important thing is not to miss those capital details that could blur everything up. Our perception is by definition subjective but we also apply a semantic compression to different chunks of it to be able to easily work with them.

This leads to another layer of subjectivity, the key is that we should be eternally vigilant.

References

Utilitarianism 1 - a much better description
Utilitarianism 2 - quote source

On semantic Ruby block constructs

2025-07-05T21:20:05Z

I was cruising around my Github notifications and I found an interesting open issue created by Jim Weirich : “The Semantic Rule for { } vs. do/end” in the Ruby style guide repository .

The semantic rule

The semantic rule says use { } for blocks where the primary purpose of the block is to return a value, use do/end for blocks where the primary purpose of the block is to execute side effects.

The main issue with this rule is that it implies the existence of some cases when one must use do/end on a single line. So what's the problem with this ? Well, most will argue it's not very good looking, it's verbose and it feels a bit hacky e.g. :

# one-liner that abides to the semantic rule
(1..10).each do |i| some_instance.side_effect = i end

versus :

# idiomatic Ruby one-liner
(1..10).each { |i| some_instance.side_effect = i }

I would say the difference is not that big and by abiding to the semantic rule one could make code more readable. Moreover it's not only about the aesthetics of code but also on its inherent semantics.

This can branch out in two directions: good, i.e., it improves code readability, or bad, i.e., it might be confusing to developers that don't know how to interpret it.

Lambdas

This can also be applied to the lambda notation:

-> { ... }
->(obj) { ... }

versus

-> do ... end
->(obj) do ... end

Lambdas have one more piece of semantic baggage, so to say: I usually use them to do some computation and return the result to be used somewhere else without creating side-effects for everything else procs are better suited.

One could argue that the { } VS do/end distinction is superfluous for lambdas.

Conclusion

Pondering on it, the visual difference doesn't seem colossal so I think I'll adhere to this rule in my codebases from now on.

References

On Ruby modules and concerns

2025-07-05T21:20:05Z

Modules are useful for highly specialized code that can be injected into other classes for fun and profit or for creating namespaces. An interesting approach is to use modules as an alternative to classical inheritance (without the usual trade-offs) : the core idea is to share an abstracted role that can be included in a set of different classes.

Roles and modules

One should start with the simplest definition of the word role :

The function assumed or part played by a person or thing in a particular situation.

“... or thing in a Particular situation” is key here so how do we encode particulars in an object-oriented way? We create classes: blueprints that we can later instantiate and use at will. Next : a function assumed by a thing i.e. a well-defined function that is used by objects in particular situations; more exactly different objects start playing a common role and when this happens it becomes clear that the common behaviour can be extracted into a module.

ActiveSupport::Concern

A concern is a nice abstraction that simplifies sharing behaviour using modules. It can be found in ActiveSupport::Concern and it just removes some boilerplate code e.g. :

module M
  def self.included(base)
    base.extend ClassMethods
    base.class_eval do
      # ...
    end
  end

  module ClassMethods
    # ..
  end
end

tl;dr: included gets called when we do something like include MyModule into a class, the base argument is the object in which we include the module i.e. a Class instance (remember that classes in Ruby are instances of Class - interestingly the class of Class is again Class, so it's all turtles all the way down).

The abstracted code looks like this :

module M
  extend ActiveSupport::Concern
  included do
    # ...
  end

  module ClassMethods
    # this gets included automatically 
  end
end

A bit cleaner, but the classic way is not bad either as long as you know what's actually going on. We all love Rails's “magic” yet one could say that using it without having any clue on what's going on behind the scenes is an exercise in futility.

Uses and trade-offs

Going back to our Concerns : what I do like is how it easily resolves dependencies -> one can ponder further upon the source -> some interesting coding going on in there.

Some simple uses for Concerns ? One can use them to apply the Extract Method refactoring i.e. “code fragments that can be grouped together”. In this 37signals article we have a simple example of a before filter that does some cookie mingling. The only issue here is that taking before filters out of the controller might result in some hard to debug code, one could argue that seeing all the filters per controller requires less mental switching than parsing include Ajax -> “oh wait this sets a before filter”.

A much better use can be found in this highly referenced article by DHH : “Put chubby models on a diet with concerns” e.g. a Taggable, Visible and Dropboxed are clusters of functionality that can be injected in other classes so that they can share a common role.

Next stop up the ladder is the DCI paradigm , from a bird's-eye view, this is a more formalized way of using/sharing roles that also includes a scaffold framework of thinking for organizing code. I'll get into the nitty-gritty details in a new post.

On Ruby 2.0 memory usage, Unicorn and Heroku

2025-07-05T21:20:05Z

On UNIX-like operating systems (e.g. Linux) there's the concept of process forking via the fork() system call. When one calls fork from a parent-process it will spawn a new child-process - that is a copy of its parent, then both processes return from fork. The child-process has an exact copy of the parent's memory in a separate address space. Due to this clearly not being efficient, UNIX implements the copy-on-write semantics (i.e. CoW): this delays the actual copying of memory until it needs to be written - simple and elegant.

The old days of Ruby 1.8.7 and REE

Historically, Ruby has been really bad at forking and I'm not referring to the language itself but to its VM implementations: especially MRI and YARV. The issue is the way garbage collection works in these versions, without entering into details, when the GC runs to clear some unused references from memory it changes every object making them "dirty" i.e. CoW fails quickly as the whole memory becomes dirty. Why is this important ? The best Rack compliant servers use pre-forking to max out all CPUs (e.g. Unicorn , Phusion Passenger ).

When you fire up a Unicorn server it creates a number of a priori configured workers via the fork() system call. On 64-bit Linux, an almost vanilla Rails 3.x application takes up ~70 MB of memory and a rather complex one ~200 MB; now multiply that by the number of available cores on your system, let's say eight and we have a memory usage spanning from 560M to a whopping 1.6G. Using Ruby 1.8.7 yields a nice bonus: there's a CoW-friendly version with an updated garbage collection algorithm written by the guys at Phusion - in the form of Ruby Enterprise Edition - REE .

This is not a solution as 1.8.7 nears EOL on June 2013 and REE is next , nevertheless REE was/is a great piece of software.

The recent release of Ruby 2.0

Narihiro Nakamura implemented the new GC algorithm - bitmap marking. In a nutshell, the Ruby VM can do its marking without actually modifying the objects; i.e., CoW works as expected now. For more details you can check out a video about Ruby's GC and a recent really nice high-level explanation by Pat Shaughnessy.

When you combine Ruby 2.0 with Unicorn you can get some pretty impressive results. Using this simple script memstats.rb I checked the memory usage with eight workers:

Memory Summary:
private_clean                   0 kB
private_dirty               1,584 kB
pss                        12,884 kB
rss                        80,152 kB
shared_clean                1,984 kB
shared_dirty               76,584 kB
size                      275,704 kB
swap                            0 kB

Based on this gist : “rss represents the physical memory that is actually used, and it's comprised of private_clean + private_dirty + shared_clean + shared_dirty” so practically ~76 MB is shared and ~1.5 MB is private. This is a huge step up from YARV 1.9.3, where there's no CoW-friendly GC, i.e., no GC-preserved memory sharing. These results are impressive, of course my app is rather trivial (it just runs this blog) so in real ones the ratio will not be as high but still big enough to save lots of RAM.

What about Heroku ?

One Heroku Dyno is limited to 512M of ram after which it starts swapping memory until it crashes and/or Heroku will send a SIGKILL and restart your app - more info . Due to the recent routing-miscommunication, we all know that the best server for a Rack compliant app is Unicorn (actually, that should be common knowledge).

# config/unicorn.rb
worker_processes 8

What happens when you upgrade to Ruby 2.0 ? You can crank up the workers as much as doubling them without hitting the hard quota.

Wrap-up

Clearly this does not benefit only Heroku users, the upgrade to Ruby 2.0 is painless as in most cases is a drop-in replacement with the added bonus of lower memory usage. The big issue is with apps that run 1.8.7 or REE as upgrading from 1.8.7 to 1.9.3 and 2.0 yields some compatibility problems.

On font rendering consistency across browsers

2025-07-05T21:20:05Z

Back in the day (i.e. when Firefox's version was a single digit) font rendering was at its best on Mozilla's browser. I remember comparing Firefox's anti-aliasing to the new-kid-on-the-block Chrome : the difference was huge.

Time went by and we all know what happened : most web developers found themselves using Chrome as their main browser for doing their work and this is exactly what happened to me. Somehow the font rendering issue went under the radar.

Fast-forward to today : I fired up Firefox to check the rendering of my blog and surprise: faux bold on all my main body text. I've tried the classic font-weight: normal and opacity: 0.99 with no luck.

After some major googling around I found there's a special CSS property that addresses this, namely: text-stroke. The irony : the article referencing this was trying to replicate the exact opposite i.e. making text render in Webkit browsers in a faux bold style à la Firefox.

Playing a bit with the property in Chrome one can easily duplicate the FF rendering style with text-stroke: 0.35px and by setting it to 0px we practically reset it ergo using the same in FF will reset its rendering. Sadly as you can see in this lovely table by caniuse Firefox and Opera don't support it, well, Opera by going the Webkit way, it will support it soon.

How about Internet Explorer? Good question indeed! And since IE10 had been out for some time, I updated my old version 9 (it needed a restart, of course) and fired it up. Results : horrendous text rendering and a very snappy experience.

I'll probably do some testing (all of this was done on Windows) on Linux and OS X soon, there I hope/should get more consistent results.

There are also:

-webkit-font-smoothing: none;
-webkit-font-smoothing: antialiased;
-webkit-font-smoothing: subpixel-antialiased;

yet they don't seem to do much.

It seems that font rendering is not consistent at all on the Windows platform. I reckon some of these problems are also due to the hardware acceleration implementation. I really dislike how Firefox renders fonts via the CSS @font-face property (and yes the Verb typeface is optimized for web).

The issue is clearly visible when using font sizes in the range of 16 ~ 32 pixels. On smaller sizes the effect is actually useful as it makes the text more readable.

Update № 1

There's a simple fix for Firefox : detection is done via JavaScript and it just adds a class to the body element, then we can do :

.firefox_is_bad section p { opacity: 0.75; }

That's just a joke I still love Mozilla's browser.

The code for easily detecting Firefox :

is_firefox: ->
  if window.mozInnerScreenX is undefined then false else true

Update № 2

Status on OS X: the same issue, yet the native antialiasing is somewhat better compared to the Windows platform.

The -webkit-font-smoothing CSS property seems to work here in Chrome. The rendering looks like:

As one can clearly see, using -webkit-font-smoothing: antialiased; renders the text best. Somehow I was living under the impression that subpixel antialiasing would render better.

Hopefully this will get fixed at some point.

References and 2026 context

Is Rubinius 2.2.3 production ready ?

2025-07-05T21:20:05Z

Ruby 2.1 was released this Christmas, great news everyone! It sports a better GC (RGenGC — generational GC), hierarchical method caching, some small syntax changes and non-experimental refinements. All in all one can expect 5% to 15% performance increase which is quite awesome.

As I was reading the comments in the Hacker News thread related to the release, one of them caught my eye - we need JIT in the MRI Ruby VM. OK but looks like everyone forgets about Rubinius, which has sported an LLVM-based JIT for some time, native threads, low-pause generational garbage collector and almost perfect support of C extensions.

Yes, we also have JRuby - it might just be the fastest implementation and when coupled with a server like TorqueBox is even faster, the main issue: some C libraries need to be swapped but as one can see later in the article this was just old thinking at play, clearly things are much better now as most gems do support JRuby without any issue.

So we have this awesome middle-ground so to say between Ruby VMs: it supports both C extensions without a problem (yet, empirically at least, some more exotic gems might fail to install) but somehow it gets ignored ?

The plan is simple, take one production Rails 4.0.2 app with all its dependencies and convert it to Rubinius, install Puma and do some benchmarking then if all good deploy to staging.

The setup

Rubinius extracted most of the standard library into gems so in order to properly boot any Ruby script that uses them one needs this into the Gemfile:

gem 'racc'
gem 'rubysl'
gem 'puma'

Notes:

rubysl — a rather cryptic name for the Ruby standard library gem
racc is a LALR(1) parser generator written by tenderlove - is also a hard requirement for Rubinius or else no booting up Rails.
puma - well this is the best server choice for Rubinius as it supports native threads

Gems that won't work with Rubinius (will update if I find more):

# gem 'oj'

Remember to comment them out or again Rails won't boot up.

For VM install and switching I'm using the good old RVM with the latest version of Rubinius 2.2.3 and Ruby 2.1.0.

On to the benchmarks!

OK for obvious reasons I can't share the source code of the app, at some point I might create a public repository with something meaty for testing. These benchmarks are for a special case only and for some good fun also so before making any decisions based on them DO TEST first on your own.

The Rails app is actually an API so most of the important parts are disabled (i.e., Streaming, DataStreaming, Rendering, and RequestForgeryProtection) also the sprockets railtie.

ApacheBench config

I used the simple ApacheBench, Version 2.3 - clearly not the ideal tool for benchmarking (one should use siege or something similar) but for a quick glance like this test it fits the job nicely.

The command to start it up: ab -n400 -c16 -T'application/json' http://localhost:3000/entries

unicorn.rb

# config/unicorn.rb
worker_processes Integer(ENV["WEB_CONCURRENCY"] || 3)
timeout 15
preload_app true

before_fork do |server, worker|
  # et cetera
end

The command to start it up: unicorn_rails -c config/unicorn.rb -p 3000

Results after some runs:

Concurrency Level:      16
Time taken for tests:   6.769 seconds
Complete requests:      400
Failed requests:        0
Write errors:           0
Total transferred:      3611600 bytes
HTML transferred:       3346800 bytes
Requests per second:    59.09 [#/sec] (mean)
Time per request:       270.766 [ms] (mean)
Time per request:       16.923 [ms] (mean, across all concurrent requests)
Transfer rate:          521.03 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   1.0      0       5
Processing:    49  267  36.8    270     331
Waiting:       44  266  36.8    269     330
Total:         49  267  36.3    270     331

Percentage of the requests served within a certain time (ms)
  50%    270
  66%    283
  75%    288
  80%    293
  90%    308
  95%    315
  98%    324
  99%    327
 100%    331 (longest request)

puma.rb on Rubinius 2.2.3

# config/puma.rb
threads 8,32
workers 1

preload_app!

on_worker_boot do
  # et cetera
end

The command to start it up: puma -C config/puma.rb -b tcp://localhost:3000

Results after several runs (so that the JIT can do its magic):

Concurrency Level:      16
Time taken for tests:   9.383 seconds
Complete requests:      400
Failed requests:        0
Write errors:           0
Total transferred:      3590400 bytes
HTML transferred:       3346800 bytes
Requests per second:    42.63 [#/sec] (mean)
Time per request:       375.311 [ms] (mean)
Time per request:       23.457 [ms] (mean, across all concurrent requests)
Transfer rate:          373.69 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       1
Processing:    84  371 105.4    348     731
Waiting:       83  363 104.1    338     728
Total:         84  371 105.3    348     732

Percentage of the requests served within a certain time (ms)
  50%    348
  66%    390
  75%    431
  80%    458
  90%    526
  95%    571
  98%    640
  99%    683
 100%    732 (longest request)

puma.rb on JRuby 1.7.9

# config/puma.rb
threads 8,32

preload_app!

on_worker_boot do
  ActiveSupport.on_load(:active_record) do
    ActiveRecord::Base.establish_connection
  end
end

The command to start it up: puma -C config/puma.rb -b tcp://localhost:3000

Gems that need replacement:

# gem 'pg'
gem 'activerecord-jdbcpostgresql-adapter'

Results after several runs (so that the JIT can do its magic):

Concurrency Level:      16
Time taken for tests:   4.019 seconds
Complete requests:      400
Failed requests:        0
Write errors:           0
Total transferred:      3590400 bytes
HTML transferred:       3346800 bytes
Requests per second:    99.53 [#/sec] (mean)
Time per request:       160.760 [ms] (mean)
Time per request:       10.048 [ms] (mean, across all concurrent requests)
Transfer rate:          872.42 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       1
Processing:    35  158  31.5    157     389
Waiting:       34  151  27.1    149     261
Total:         36  158  31.5    157     389

Percentage of the requests served within a certain time (ms)
  50%    157
  66%    166
  75%    173
  80%    177
  90%    189
  95%    204
  98%    232
  99%    260
 100%    389 (longest request)

Conclusion

The poor Rubinius performance might be related to the racc gem as it might be really slow as detailed in this GitHub thread

43 req/s vs. 59 req/s (I disabled cache and the app produces lots of ActiveRecord objects; that's why the numbers are rather low) makes Rubinius, for now, not a good choice for this particular Rails app.

Update

Thanks to headius I've revised the benchmarks: - apparently my VM was accessing only one core (thus the initial abysmal performance of Rubinius and JRuby) - bumped to four - updated all benchmarks and also added JRuby 1.7.9

   jruby 99.53 #################################
   cruby 59.09 ###################
rubinius 42.63 ##############

As one can clearly see from the chart above JRuby is the winner by an impressive margin and with only one gem change I think it deserves to be pushed to staging.

Installing a rails mysql stack on my laptop was a bit tricky

2025-07-05T21:20:05Z

I’ll keep this short: firstly I’ve downloaded the Ruby Windows installer from here , at the time of writing the version was 1.9.2-p0. The problem with this one is that Ruby crashes into oblivion from time to time (mostly after lots of page refreshes); after a Google search I’ve found out it’s a Windows bug (yeah on *nix it works like a charm) so not much really more to do except waiting for the next release, compiling myself the latest version or if you just want to be safe just get the 1.8.7 or .6 release, should work just fine (that’s what I have on my desktop with Rails 2.3.5 and works really well—for development purposes).

Ok, time to install rails: gem install rails -v 2.3.5 --no-rdoc --no-ri (to be noted I’m using an older version you can skip the -v to install the latest Rails 3). The last two parameters should skip installing the offline documentation (I don’t really use that, so why bother installing all those small files...)

Next comes the mysql part, this was fun: the normal way to do it is to install gem install mysql, have your mysql/bin (that’s where libmySQL.dll resides) in the Windows PATH environment variable and hope everything works just fine. If it doesn’t, well you can try the classic hack of putting (and by that I mean copying, not moving, the file) libmySQL.dll into the ruby/bin folder. Needless to say, none worked on my setup.

My way: gem install mysql2, after I modified my database.yml to use the adapter, it worked! Kudos to brianmario for coding that.

All done !

References

Ruby 1.9.2-p0 - for windows
mysql2 - source code on github, again kudos to brianmario

Improve Rails performance by adding a few gems

2025-07-05T21:20:05Z

After working with Rails for some time, you start nitpicking about how to improve it. This is the first in a series of articles on how to improve (even marginally) Rails's performance.

I'll focus on a bunch of gems that speed up, in some cases considerably, small parts of Rails, like HTML escaping, the String#blank? and JSON utils.

Benchmarking methodology

Methodology is a strong word for just running wrk a couple of times in the console but I'm not searching for the holy grail here, just to get a raw idea.

I switched from the old ApacheBench (ab) to wrk :

wrk is a modern HTTP benchmarking tool capable of generating significant load when run on a single multi-core CPU.

wrk -t10 -c10 -d10s http://localhost:3000

This runs a benchmark for 10 seconds, using 10 threads, and keeping 10 HTTP connections open i.e. this should suffice. Just remember to benchmark on your actual app to see the real improvements.

The escape_utils gem

Just faster HTML escaping via the lovely escape_utils gem. In order to use it in Rails one needs to add an initializer that patches things up:

begin
  require 'escape_utils/html/rack' # to patch Rack::Utils
  require 'escape_utils/html/erb' # to patch ERB::Util
  require 'escape_utils/html/cgi' # to patch CGI
  require 'escape_utils/html/haml' # to patch Haml::Helpers
rescue LoadError
  Rails.logger.info 'Escape_utils is not in the gemfile'
end

The logic to test it:

def escape_utils
  @escape_me = <<-HTML
    <body class="application articles_show">
      <!-- Responsive navigation
      ==================================================== -->
      <div class="container">
        <nav id="nav">
      <ul>
        <li><a href="/"><i class="ss-standard ss-home"></i>home</a></li>
        <li><a href="/home/about"><i class="ss-standard ss-info"></i>about</a></li>
        <li><a href="/contact"><i class="ss-standard ss-ellipsischat"></i>contact</a></li>
        <li><a href="/home/projects"><i class="ss-standard ss-fork"></i>projects</a></li>
        <li><a href="/tags"><i class="ss-standard ss-tag"></i>tags</a></li>
        <li><a href="/articles?query=code"><i class="ss-standard ss-search"></i>search</a></li>
      </ul>
    </nav>
    <a href="#" class="ss-standard ss-list" id="nav-toggle" aria-hidden="true"></a>
  HTML

  render inline: "Hello  world <%= @escape_me %>"
end

With standard Rails:

Running 10s test @ http://localhost:3000/sidechannels/bench
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    35.40ms    3.55ms  64.70ms   91.98%
    Req/Sec   142.19     11.68   164.00     83.12%
  2837 requests in 10.00s, 4.92MB read
Requests/sec:    283.61
Transfer/sec:    503.34KB

With the escape_utils gem:

Running 10s test @ http://localhost:3000/sidechannels/bench
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    34.06ms    3.89ms  63.92ms   89.10%
    Req/Sec   148.65     13.36   180.00     75.94%
  2960 requests in 10.00s, 5.46MB read
Requests/sec:    295.98
Transfer/sec:    558.72KB

The fast_blank gem

Living under the impression that the blank? method is too slow? Say no more and just try the fast_blank gem!

Just add gem 'fast_blank' to your Gemfile and this should speed up quite nicely the String#blank? method as described in this article . For testing I just added this code:

fast_blank is a simple extension which provides a fast implementation of Active Support's String#blank? method

  def fast_blank_test
    n = 1000

    strings = [
      "",
      "\r\n\r\n  ",
      "this is a test",
      "   this is a longer test",
      "   this is a longer test
      this is a longer test
      this is a longer test
      this is a longer test
      this is a longer test"
    ]

    Benchmark.bmbm  do |x|
      strings.each do |s|
        x.report("Fast Blank #{s.length}    :") do
          n.times { s.blank? }
        end
      end
    end

    render nothing: true
  end

With standard Rails:

Running 10s test @ http://localhost:3000/sidechannels/bench
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.40s   207.72ms   1.58s    92.68%
    Req/Sec     3.10      2.11     6.00     53.66%
  69 requests in 10.01s, 33.08KB read
Requests/sec:      6.90
Transfer/sec:      3.31KB

With the fast_blank gem:

Running 10s test @ http://localhost:3000/sidechannels/bench
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.33s   179.56ms   1.41s    93.33%
    Req/Sec     3.07      0.80     4.00     40.00%
  72 requests in 10.00s, 34.52KB read
Requests/sec:      7.20
Transfer/sec:      3.45KB

The oj gem

# oj gem
gem 'oj'
gem 'oj_mimic_json' # we need this for Rails 4.1.x

The test logic is simple, just serialize all articles into JSON:

class SidechannelsController < ApplicationController
  def oj
    render json: Article.all
  end
end

With standard Rails serializers:

Running 10s test @ http://localhost:3000/sidechannels/bench
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   108.37ms    5.12ms 134.90ms   83.33%
    Req/Sec    45.76      3.60    55.00     57.69%
  922 requests in 10.00s, 57.41MB read
Requests/sec:     92.17
Transfer/sec:      5.74MB

With the Oj gem:

Running 10s test @ http://localhost:3000/sidechannels/bench
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    78.06ms    4.43ms  92.83ms   81.31%
    Req/Sec    63.64      5.33    71.00     64.49%
  1277 requests in 10.00s, 79.83MB read
Requests/sec:    127.65
Transfer/sec:      7.98MB

Using jemalloc

OK, this is not really a gem, if you want to dig into it then do check out my gist . In initial testing it didn't yield many performance gains, at least for my use case.

note: it will be included by default in Ruby at some point.

update: do try the jemalloc gem by kzk:

gem install jemalloc

je -v rails s

Dig into your Rails app

Fear not and use MiniProfiler with the awesome FlameGraphs by Sam Saffron.

Conclusion

Depending on what your app is doing you might want to add to your Gemfile some of these gems, I usually add them all just for good measure (you might want to check your RAM usage and have a full test suite before doing this though).

The oj gem is just great for a Rails-based JSON API where you can drop the views and just serialize using representers or your pattern of choice.

How to Web conference, random thoughts, mostly live - five years later

2025-07-05T21:20:05Z

Almost five years since the last post about How to Web [0] - wow, that's a large slice of the space-time continuum. I recall I almost started this blog for stuff like this, good memories [1].

Half a decade later, what's changed, one might ask? Well, the scale looks bigger and so far the talks have been interesting at least the ones I got to see.

Colette Ballou's [2] quick talk about being a decent human being i.e. not a total jackass when asking a potential person for advice.

The idea behind Mendeley [3] is quite interesting and Jan Reichelt's talk explained it eloquently.

Not bad for half a day.

References

How to Web Conference, random thoughts, mostly live

2025-07-05T21:20:05Z

Sadly, today I’ve arrived a bit late, where "a bit" means a lot; I’vevolatile and utopic place most of the time.

In very few domains you can take an idea and with small or no resources (money) and bring it alive and running. I mean, actually thinking about it, how can’t that be exciting ?! Having an idea and turning pure thoughts into something that can actually reach people and the real world... that’s just mind boggling.

I’ve stumbled over a new concept: "lifestyle business", apparently you can have two kinds of businesses (assuming they will work): you can go big, invest a lot, get international and all that stuff or you can keep it small as a lifestyle, you live for your business you burn your thoughts making it better and better, I really like that idea, it’s inspiring.

“Some heavily 37signals inspired ideas”

Also another interesting concept: bootstrapping. More on that in another article (it’s probably going to be a Rails article)

And last update on How to Web: it was awesome and it’s not just about the conference; it’s about the great people I’ve met or watched in full action, if they can do it then we can do it also, it’s all about passion and loving what you do and never taking yourself too seriously, self-irony from time to time is great, nobody is perfect, perfection is not the goal, accepting the imperfection and making the best of it is the key.

All in all, great experience, kudos !

Reference

rework - this one is a must read

How to reduce the size of your VMs

2025-07-05T21:20:05Z

As the host OS I use Windows 8 (just upgraded to 8.1), Well, why, one might ask? It is rather simple: Steam and after some dreadful searching and configuring tools I managed to install the basics for writing and deploying code: Vim, Git, PuTTy and a decent console replacement like Console2 [0].

Of course those aren't enough as 80% of my coding is *nix dependent and I wouldn't run it on anything else; actually I'm still thinking of dropping Windows for something like ArchLinux [1] I fiddled with it and enjoyed all the low level stuff that just doesn't exist in Ubuntu Desktop.

Needless to say I use lots of VMs: I currently have three images that I use daily: Ubuntu Desktop, Ubuntu Server and an old Windows XP (well, I don't use it daily more like monthly). The problem of using just a few VMs with many projects is that it involves a lot of HDD thrashing (i.e. git, deleting and creating lots of files).

What I did not realize is that my VMs were growing bigger and bigger by the day while their internal HDD space usage stayed mostly the same as I deleted old files and cleaned them up. For reference these were the initial sizes:

The historical sizes are compared below.

While trashing the SSD with all the writes and deletes I was expanding the VHDs despite the fact that I deleted the files in the VM. The cause: the actual blocks weren't zero-filled so running a VM compact wouldn't yield any results.

With the --compact option, can be used to compact disk images, i.e. remove blocks that contain only zeroes. This will shrink a dynamically allocated image again; it will reduce the physical size of the image without affecting the logical size of the virtual disk. Compaction works both for base images and for diff images created as part of a snapshot.

The fix was clear: one needs from time to time to nullify the free space. After doing some quick research I've found easy ways to do it on every platform.

On Linux

The first version is using a tool like secure delete but with a very fast run:

sudo apt-get install secure-delete
sfill -f -z -l -l -I -v /

Where:

-f  fast (and insecure mode): no /dev/urandom, no synchronize mode.
-z  last wipe writes zeros, not random data.
-l  lessens the security (use twice for total insecure mode)
-I  just wipe space, not inodes
-v  is verbose mode.

Or a much simpler way:

sudo dd if=/dev/zero of=/bigemptyfile bs=4096k
sudo rm -- /bigemptyfile

This will fill the entire empty space with a null file that is erased at the end. I haven't tested this too much, it might yield issues but is faster than the first version.

On Windows

On Windows XP one just has to download SysinternalsSuite [2] and run sdelete –z from the command prompt.

OK once all of this is over: shut down the VMs and run compact on the VHD. Using VirtualBox, run VBoxManage modifyhd thedisk.vdi --compact from the host console. Using VMware, consult the product's disk-compaction documentation.

Results

VM	Before	After	Reported reduction
Ubuntu desktop	19.7 GB	11.0 GB	~ -45%
Ubuntu server	8.0 GB	4.3 GB	~ -47%
Windows XP	7.9 GB	6.6 GB	~ -16%

That's a whopping 13.7 GB out of my main 128 GB SSD that I use as the system drive, not bad, not bad at all !

References

How I speeded up my browsing experience by a really nice margin

2025-07-05T21:20:05Z

From time to time I like to optimize a bit my Windows machine, yet mostly all I do is fine-tuning, nothing really spectacular. This time while I was browsing the net and thinking about one of my old nags (browser performance loading several tabs—to be more exact: Firefox loading up 20+ tabs) I realized something really simple.

Firstly though, let me explain the problem. When Firefox loads up with a lot of tabs open since the last session (I leave tabs opened using SessionManager, I use them as a to-do list for the next day) it takes very long (30–90 seconds) to load them all up, mostly because Firefox is reading unchanged files from its cache.

Back in the day, I’ve tried to solve this problem by saving the cache on a speedy USB stick (this way I would get much better random access time of small files but the sequential speed was really low).

As I was saying, while searching the interwebs I’ve stumbled on a nice little utility that can create RAM drives, needless to say my old idea just got better, what about a RAM drive especially for Firefox and IE cache ? It doesn’t need to be big (50 MB each would be enough) and I don’t really care about the safety of the data stored there (after all if the cache gets corrupted or lost, the browser will just redownload or a trusty CTRL+F5 would fix the problem).

It was sitting at the back of my mind for too long

Configured my Ram Drive, moved firefox and IE cache folders there and then reloaded my Firefox session with 20+ tabs. Results ? Well, just next to amazing, everything runs snappy, but now I’ve found another bottleneck: my CPU.

Reference

Ram Drive - RAM-disk utility

Chunked transfer encoding in Rails (streaming)

2025-07-05T21:20:05Z

Anyone who has written a little PHP knows what the flush() family of functions do. The ideal usage scenario for using chunked transfer[0] is when we have something costly to render e.g. the first three most recent articles on a blog. Why, one might ask?

Why stream

It is rather simple: in a normal Rails render, the server finishes producing the response before sending the body; that delays the browser from discovering assets placed in the layout.

Using the Transfer-Encoding: chunked header, the server will send chunks of the rendered page back to the browser so in the case of Rails, it starts with the layout and sends out the <head> part including assets like js and css.

It's clear how this helps the rendering of the page on the client side : get the first chunk containing the <head> with assets, immediately start loading the assets while waiting for the rest of the response. Of course, browsers nowadays include lots of micro-optimizations that might already do something similar but still this remains a good practice.

Rails implementation

Implementation wise, you just need to add to your controller methods something like :

class YourController < ApplicationController
  def index
    @articles = Article.most_recent
    render stream: true
  end
  # other controller logic
end

Unicorn

The latest version of Unicorn (4.x) comes with support for chunked responses by default.[1] You can always add to your unicorn_config.rb something like:

# :tcp_nopush This prevents partial TCP frames from being sent out
# :tcp_nodelay Disables Nagle’s algorithm on TCP sockets if true.
port = ENV.fetch("PORT", "3000").to_i
# the ENV["PORT"] is a Heroku environment variable
listen port, tcp_nopush: false, tcp_nodelay: true

Rails rendering caveats

We also have some quirks when using streaming in Rails because of the inversion of template rendering order[2]:

When streaming, rendering happens top-down instead of inside-out. Rails starts with the layout, and the template is rendered later, when its yield is reached.

tl;dr: use provide instead of content_for when you have multiple calls to content_for otherwise it will break the purpose of streaming and/or it will concatenate the values from content_for.

New Relic

There's also a “small” issue with NewRelic agent and Heroku: you need to disable browser instrumentation or else you'll get a blank page[3], thankfully the fix is rather trivial:

# config/newrelic.yml
  browser_monitoring:
    # By default the agent automatically injects
    # the monitoring JavaScript into web pages
    # Turn this to false
    auto_instrument: false

There's also ActionController::Live that can be used to create a simple Rails 4 chat application[4][5].

References

Buzzwords and manifestos

2025-07-05T21:20:05Z

Do we really need them? I mean sometimes I ask myself what’s the point of all the so-called ways to get things done or tons of guides for getting you to be a “better” you, like NLP, the secret of life and all that stuff.

To quote Nassim N. Taleb:

“I went to a happiness conference: researchers looked very unhappy” - Nassim N. Taleb

This really strikes me as a big problem of modern society, maybe it is something related to herd-mentality, we want to be stupid and not believe or motivate ourselves by the sheer power of our will. We suffer from a disease: the laziness of the will, gone is the will to power (or any other philosophical system that puts you in control of yourself, like existentialism for a change), nowadays we have a new direction: will to brainwash, will to not have a will. It is really sad and I find myself in the same situation too from time to time, yet solving half of the problem is realizing that you have it.

I think therefore I might be wrong: let’s just say, for the sake of the argument, that all of these systems are in fact useful. They might guide us to a better path, yet the problem is that it is not your path, someone else created it to fit as many yous as possible; generalizing and having a reductionist view of reality makes it inauthentic for the individual. I’m not saying that everything else that’s not ours is irrelevant or not useful, no, what I mean is that by choosing what we like from the outer world and mashing all of that in something we can use that makes sense to us is far more effective than blindly following some program and in the end realizing that nothing had changed.

So let’s drop the buzzwords or blindly following someone else’s system without taking it through a critical hell ride in our minds.

References

A Kick In the Pants - a great pdf
via - themadtolive.com

Building a small blog cms in rails

2025-07-05T21:20:05Z

Yes, building a blog CMS in Rails is apparently very simple, well to be true it’s simple if you want something really limited like a post model, a couple of static pages, controllers and one for the contact form and you’re settled. Actually for something like this one can use Sinatra (not to say that Sinatra is better for small applications, but you really don’t need all the Rails stack, of course Rails 3 is more modular and everything, but still).

That’s why the CMS (I really dislike this word) backing up my personal site it’s not going to be something trivial, I’ve actually based it on a more general CMS I’ve been using for projects I work on.

“It is better to take many small steps in the right direction than to make a great leap forward only to stumble backward.”

From the vanilla state, I’ve got RBAC implemented (keeping in mind that I’m the only one posting articles on the site it is a bit useless) - this will cost some small performance in the admin but having it online will let me test it and improve it for actual usage in real world.

References

CMS - content management system
Sinatra - a DSL for quickly creating web applications in Ruby with minimal effort
RBAC - Role-Based Access Control

A few words on frontend performance optimizations

2025-07-05T21:20:05Z

I love optimizing stuff, sometimes I even break the rule (when I have time) and optimize just for the sheer fun of it. I’ve been using on my blog RequireJS for some time but in the last few days I’ve rewritten the whole init script to use LABjs .

“Why would I do such heresy?”

Well, mostly because I didn’t like the way RequireJS works with jQuery (this might be a bit outdated): I was loading up a custom file with jQuery and RequireJS bundled together then I would load up other JS files normally.

With LABjs I only have one JS file loading, that being LABjs itself, after that I load jQuery and GA via Google CDN, which is pretty fast: the DOMContentLoaded event triggers a bit more quickly now. This is good stuff to know and use for a busy site with lots of js.

Hopefully at some point I will post some graphs with some benchmarking. The good stuff is that before jQuery 1.4, you couldn’t have the LABjs script first then load jQuery; that’s because of the way jQuery did the check if the DOM had loaded, yet now they’ve fixed that and all seems to play nicely.

Next step? a failsafe if the CDN breaks or takes too long to serve the js files, I’ve researched the code a bit and it’s pretty easy, I shall test it soon.

References

RequireJS - before
LABjs - now

Semantic search in Rails using sqlite-vec, Kamal and Docker

2026-03-29T23:20:11Z

I’ve been reading a lot about search lately: kNN, BM25, RRF and related ideas, both within Elasticsearch and in isolation. With the advent of LLMs, especially open-weight models, plus modern hardware, it feels like a good time to approach some of this in a pragmatic way.

On the blog I'm already using a form of BM25 via SQLite’s FTS5 extension , which enables full-text search, similar to the pg_search gem which uses textsearch on Postgres.

What I wanted to do next was to experiment with embeddings and enable a form of semantic search too.

If you want to try it out, it’s live at /semantic-search

While searching around, I came across Alex Garcia's sqlite-vec. He describes it as “a no-dependency SQLite extension written entirely in C that runs everywhere”. That was appealing in itself since I did not want to introduce a separate client/server vector database for this small Rails app. The stable path used here performs brute-force search, which felt perfectly reasonable at my scale. As of June 13, 2026, sqlite-vec’s official ANN tracking issue #25 remains open; however, the v0.1.10 alpha releases introduced experimental DiskANN/ANN work. That experimental support is distinct from the stable brute-force approach in this article.

The next step was to use a model from Hugging Face, create embeddings for all my articles, then enable kNN search using a local Docker container on my server.

Benchmarks

I tested: EmbeddingGemma , Multilingual-E5-large and *E5-base . As a benchmark, I used my own articles and evaluated the results manually with a sample size of one: myself. This was an informal comparison on one corpus and machine, not a controlled or generalizable benchmark.

Memory ratio comparison (lower is better)	Ratio
embeddinggemma-300m / e5-base	1.16x
e5-large / e5-base	2.07x
e5-large / embeddinggemma-300m	1.78x

Maximum ratio: 2.07x.

MEMORY RATIO MAP (max ratio = 2.07x; lower is better)

embeddinggemma-300m / e5-base1.16

1.16x

e5-large / e5-base2.07

2.07x

e5-large / embeddinggemma-300m1.78

1.78x

Memory-wise, *E5-large eats the most RSS memory (~4GB), E5-base is the lightest and EmbeddingGemma is right in the middle (~2GB). When it comes to actual results, Gemma returned similar results as *E5-large, at least according to my empirical results tested on my data.

I ran some benchmarks on latency on my MBP M1 Pro. CPU run, cold cache (the model was loaded into memory on each run), one process: model load + one encode:

Model	Dimensions	Memory	Time
intfloat/multilingual-e5-base	768d	1.95 GB	~6.47s
google/embeddinggemma-300m	768d	2.26 GB	~6.24s
intfloat/multilingual-e5-large	1024d	4.03 GB	~7.37s

EMBEDDING MODEL MEMORY IN GB (lower is better)

intfloat/multilingual-e5-base1.95

768d

google/embeddinggemma-300m2.26

768d

intfloat/multilingual-e5-large4.03

1024d

EMBEDDING MODEL TIME IN SECONDS (lower is better)

intfloat/multilingual-e5-base6.47

~6.47s, 768d

google/embeddinggemma-300m6.24

~6.24s, 768d

intfloat/multilingual-e5-large7.37

~7.37s, 1024d

I settled on Gemma because it was much lighter than *E5-large while giving similarly good results on my own data.

Rails implementation

In order to use this in my Rails blog, I decided the best approach would be to have a separate Docker image for a small service running Gemma with two API endpoints:

+--------------------------------------------------------------------------+
| EMBEDDING API FLOW                                                       |
+--------------------------------------------------------------------------+
| GET /health                                                              |
|   |                                                                      |
|   v                                                                      |
| 200 OK                                                                   |
|                                                                          |
| POST /embed                                                              |
| { "query": "text to embed" }                                             |
|   |                                                                      |
|   v                                                                      |
| 200 OK                                                                   |
| {                                                                        |
|   "embedding": [0.01, -0.02, ...],                                       |
|   "dimensions": 768,                                                     |
|   "model": "google/embeddinggemma-300m"                                  |
| }                                                                        |
+--------------------------------------------------------------------------+

This runs within the Docker network created by Kamal so it will be accessible by the Rails app. My VM has 6GB of RAM and two Ampere Arm vCPUs; RAM-wise, it should fit with some headroom for the Rails app too.

The current performance on the VM looks like this:

When    Article ID  Operation   Source  Status  Duration    Dims    Bytes   Model   Error
2026-03-29 23:30:03 46  upsert  callback    success 3368ms  768 8819    google/embeddinggemma-300m  -
2026-03-29 23:28:12 46  upsert  callback    success 3428ms  768 8819    google/embeddinggemma-300m  -
...
etc.

Latency range (ms)	Count
0-999	2
1000-1999	18
2000-2999	10
3000-3999	15
4000-4999	4
5000-6999	1

EMBEDDING LATENCY HISTOGRAM (ms)

0-9992

1000-199918

2000-299910

3000-399915

4000-49994

5000-69991

The median response time for the API is ~2726 ms, RAM: ~2.5GB in use by both the embedding service and two Puma workers. Given this is a really low-spec VM, I'm quite happy with the experiment so far given there's no cache at all in the hot path.

On the app side, the implementation is fairly simple: add the "sqlite-vec" gem, a route for testing the kNN search /semantic-search and a section in the admin panel where I can trigger the creation of embeddings for my articles.

This is what the Rails flow looks like as an ASCII diagram:

Rails app                     Embedding service
(SemanticSearch + sqlite-vec) (embedding-inference:8765)
---------------------------   ----------------------------
INDEX / UPSERT FLOW
Admin regen
        |
        v
ArticleEmbedding#upsert_for(article)
        |
        +--> available? --no--> trace(skip/error); return false
        |
        +--> PassageBuilder.build_article(article)
        |
        +---------------------------> POST /embed {"query":"passage: ..."}
                                     |
                                     v
                         200 {"embedding":[...],"dimensions":768,"model":"..."}
        <----------------------------+
        |
        +--> validate dims == 768
        +--> delete old row + insert new row in article_embeddings

And this is what happens when you click search on /semantic-search :

GET /semantic-search?query=...
        |
        v
Searcher.search(query)
        |
        +--> PassageBuilder.build_query(query)
        +---------------------------> POST /embed {"query":"query: ..."}
        <---------------------------- 200 {"embedding":[...],"dimensions":768}
        +--> sqlite-vec KNN MATCH [query_vector], k = limit
        +--> join published articles, order by distance ASC
        v
Render ranked semantic results

The embedding service

The inference component is documented as the EmbeddingGemma service for Rails and Kamal ; that page summarizes the HTTP contract and deployment boundary. The full source remains available in mp-com-embeddings .

It runs on Python/Torch and uses the sentence_transformers library, small excerpt from the POC:

def load_model(model_name: str, token: str | None, verbose: bool) -> SentenceTransformer:
    kwargs: dict[str, Any] = {}
    if token:
        kwargs["token"] = token

    return SentenceTransformer(model_name, local_files_only=True, **kwargs)

This is still an early experiment, but it already feels like a practical complement to FTS5 rather than a replacement for it.

BM25 remains great for exact terms and titles, while embeddings help when the wording drifts but the intent stays the same. Next up are a home-brewed RRF implementation and a more rigorous look at performance.

Notes

kNN - k-nearest neighbors, a way of finding the closest vectors to a given query embedding.
BM25 - Best Matching 25, a ranking function commonly used in keyword-based full-text search.
RRF - Reciprocal Rank Fusion, a simple way to combine multiple ranked result sets, often used in hybrid search setups.

Using RVM for quite some time? You should clean it up a bit

2025-07-05T21:20:05Z

I can't even remember the last time I ran rvm implode, I'd reckon I've been using RVM for about three years.

Sure: I always update it via rvm get stable but I never really clean up old Rubies or gems, I only run bundle clean --force in each repository from time to time since I don't always use bundle exec.

In any case, time to see how much space it eats up on macOS via rvm disk-usage all:

  Downloaded Archives Usage: 1.3M
  Repositories Usage: 0B
  Extracted Source Code Usage: 5.2M
  Log Files Usage: 28K
  Packages Usage: 0B
  Rubies Usage: 298M
  Gemsets Usage: 11G
  Wrappers Usage: 212K
  Temporary Files Usage: 0B
  Other Files Usage: 5.6M
  Total Disk Usage: 11G

Eleven gigabytes in total, almost all of it in gemsets according to this breakdown, wow, that's something. Let's try to clean this up a bit:

Step one

Always update RVM to its latest stable release:

$ rvm get stable

Step two

Share the gem cache with all Ruby versions (note this might introduce some subtle bugs if you like to edit your gems like me for debug purposes):

$ rvm gemset globalcache enable

Step three (attention destructive)

Before using a destructive third-party cleanup script, back up what you need, inspect the script, and prefer a dry run or a current RVM-supported cleanup command. Do not assume this old script is safe for a current installation.

The script by kugaevsky was what I used to further clean up my gems.

Note:

This process could be too destructive sometimes and you may need to run 'bundle' command from your project directory.

Step four

Let RVM clean-up after itself:

rvm cleanup Lets you remove stale source folders / archives and other

$ rvm cleanup all

Note: this will take some time to complete.

Results

$ rvm disk-usage all
  ...
  Total Disk Usage: 9.0G

Not bad (let's keep in mind that I did not remove any gemsets or Ruby installs and for my main projects I didn't need to run bundle after running kugaevsky's script).

Btw. if you're using a VM for development you can try this afterwards to further reduce its size.

Credits:

Tips: macOS save screenshots as JPEG in a different location

2025-07-05T21:20:05Z

I'm not really sure why taking screenshots in macOS defaults to PNG file format. I just googled this and the "answer" was:

MacOS captures screenshots using PNG as the default image format, which provides lossless compression and preserves image quality while creating relatively small files.

OK - I can understand somewhat the logic behind this - "we're a premium brand, even the screenshots should be premium, jokes aside, whilst I agree with the part about the format being lossless I'm sure (and don't call me Shirley!) that the part about small files is non-sense.

PNGs, especially when using "Retina"-mode HiDPI, can create large files because the format default compression engine is DEFLATE which is OK but the problem is not the algorithm itself, the issue is that it has to deal with a large set of data (lossless compression i.e. not one pixel can be lost). When using a 4K display in 1080p mode - that translates to really big files (usually a couple of megs). Actual PNG-versus-JPEG size savings depend on the screenshot’s content and whether lossy compression is acceptable for the intended use.

Why is this an issue for me? I keep all my screenshots and sync them in iCloud. It is rather useful to have them - assign dates to images over large periods of time and you can reconstruct a bit of the past e.g. "What was I doing that day? Oh, I was making a meme about moths".

Change the screenshot format

But I digress, I always forget the command to change the default image format to jpeg and as far as I know there is still no global UI way to set it - therefore here goes, the magic commands:

defaults write com.apple.screencapture type jpg
killall SystemUIServer

The first line is easy to decipher as for the second one the only question is what SystemUIServer is - well, according to its man page:

SystemUIServer(8)            System Manager's Manual           SystemUIServer(8)

NAME
     SystemUIServer – Presents status items in the upper right of menu bar

DESCRIPTION
     SystemUIServer is a system service which presents status items in your menu
     bar.

     There are no options for SystemUIServer, and users should not run
     SystemUIServer manually.

macOS                             July 4, 2018                             macOS

Change the save location

The cherry on the top? How to set the location of your newly saved JPEG screenshots:

Command + Shift + 5 => there's an UI at the bottom where you can click "Options" and select the new folder where the screenshots will be saved.

The perils of writing request specs using concurrent-ruby under the JVM

2025-07-05T21:20:05Z

This article describes a 2017 JRuby, concurrent-ruby, and RSpec setup. Current APIs, integrations, and behavior may differ, so the workaround below should be read as historical rather than current guidance.

When I write an API, though I'm not a hard core TDD practitioner, I do like writing specs - especially request specs that test the whole stack.

Adding them into an API is fast and yields quite good results compared to an app with a UI where you have to use chrome-cli or phantomjs just to get near that level but at the cost of painfully slow execution time (yes, even if you optimise them to hell and back and get a runtime of five minutes - they're still slow in my book).

Anyhow, for some context - I've been writing Ruby APIs for quite some time but using the classic CRuby VM/interpreter - this time we switched to JRuby (thanks to Max ) since we needed to render extremely quick JSON responses (i.e. 202 status codes) - so everything from ActiveRecord CRUD operations to processing business logic is done using concurrent-ruby with Futures and ThreadPools (which on JRuby use Java's native implementation - awesome stuff since one can play with STM and all that good stuff - if required).

Next stop: the core of the issue: running request specs with all this parallelism in the background breaks most of our specs because RSpec is not aware of anything which runs in parallel and the inherent non-deterministic nature of running code in parallel.

The initial fix for this was to add a helper that basically forces a shutdown of the ThreadPool which will block until it's done - this "ensured" that all the parallel tasks (like creating a record) would finish before we got to the expect part in the specs. All nice and rosy except it did not work as expected.

The failing synchronization approach

This was the initial implementation, by the way:

def wait_for_thread_pool!(sleep_time = nil)
  thread_pool_executor = executor.instance
  pool = thread_pool_executor.executor

  # shutdown the pool and wait as long as it takes
  pool.shutdown
  pool.wait_for_termination

  # we want a fresh thread pool for the next test
  thread_pool_executor.send(:initialize)
end

This is quite self-explanatory - it issues a ThreadPool shutdown which waits for all the threads to finish their work - the problem? In 10% of the cases using RSpec random spec execution it failed.

Running tests sequentially

For the time being - the next best fix was to monkey patch the library (well, to be more precise our adapter for it) in order to run everything sequentially - especially keeping in mind that concurrent-ruby is an externally tested library and the issue should be an odd interaction between RSpec, DatabaseCleaner and concurrent-ruby.

In any case until I can start digging into all those dependencies and see what the actual issue was this fixed the issue:

# Run everything sequentially for now
def disable_parallelism!(context: nil)
  case context
  when :context_a
    future.instance_eval do
      def execute(executor: nil, &block)
        block.call
      end
    end
  when :context_b
    future.class_eval do
      def add_observer(observer)
        @observer = observer
      end

      def initialize(opts = {}, &block)
        @block_to_call = block
      end

      def execute
        proc_response = @block_to_call.call
        @observer.update(time.now, proc_response)
      end
    end
  end
end

I usually avoid monkey patching stuff like this - but then again this is also where monkey patching can give you some breathing time and keep you sane whilst the long process of debugging why:

pool.shutdown
pool.wait_for_termination

not doing its job properly can continue as an async (pun intended) task.

NB: please read the Updates section below on how this was fixed - to completely avoid the monkey-patching we can use:

def disable_parallelism!
  CustomExecutor.instance.executor = Concurrent::ImmediateExecutor.new
end

Regarding specs/coverage - the next step is to improve code-coverage in the unit-tests realm to ensure all the small parts are working correctly.

Conclusion

JRuby + concurrent-ruby is a boon - there are some drawbacks as pointed out above and many more which I'll detail in future posts but it really pays off when you really need quick responses. En plus, concurrent-ruby literally levels up JRuby to a place where it can compete with Elixir, well Erlang's concurrency model (yes it has Actors but they're in the edge branch for now). Its abstractions are top-notch and they remove a lot of pain from dealing with Threads with some minor caveats.

Updates

After the r/ruby discussion some updates are required:

A small caveat here: it works correctly except when using Futures with the option dup_on_deref set to true.

This feature was implemented in concurrent-ruby by jrochkind here i.e. Improve behaviour when posting to a shutdown thread pool

The analogue programmer in the land of LLMs

2025-07-06T14:40:06Z

It's been a while since I've posted, for obvious reasons a lot has changed in the realm of programming.

LLMs, "agentic" coding et al. I've started using them almost from day one, when they were pretty bad and they could barely generate some readable text in their images.

When it comes to coding, being in my late 30s, I'm clearly what I'd call an "old-school" programmer: I'm using vim with a couple of plug-ins, a fast terminal emulator, minimalistic Docker, brew on MacOS i.e. nothing fancy, not even using IDEs.

I like my dot-files, I love the idea of slowly improving them, it's a nice hobby that keeps me anchored and reminds me to keep learning new things.

This is just to add a bit of context in order to make my bias clear when it comes to LLMs and using them.

My main gripe with using LLMs for coding is that they incur a cognitive debt and no, I'm not quoting all the studies around this problem (nothing wrong with them), this is purely from my empirical point of view.

A small LLM-generated script

For example, I was cleaning up my cloud storage, which is a mess of lots of tiny files moved from different cloud storages: Google Drive to Dropbox to iCloud. Over the years this generated a lot of duplicate files i.e. bad syncs, the infamous file_name 2.jpg.

As I usually do, I applied the brute-force approach and started cleaning them up one by one - this got tedious fast so I was ok, hello generic-LLM, please write a Ruby script to remove these kinds of duplicates. The generated code looks like this:

#!/usr/bin/env ruby
require 'optparse'
require 'fileutils'
require 'find'
require 'digest'

# CLI options
options = {}
OptionParser.new do |opts|
  opts.banner = "Usage: ruby dedup.rb [options] /path/to/dir"

  opts.on("-d", "--delete", "Delete duplicate files") do |d|
    options[:delete] = d
  end
end.parse!

# Directory check
directory = ARGV[0]
unless directory && Dir.exist?(directory)
  puts "Please provide a valid directory path."
  exit 1
end

# Helper to detect duplicates in "filename 2.ext" style
def find_duplicates(files_by_dir)
  duplicates = []

  files_by_dir.each do |dir, files|
    files.each do |file|
      match = file.match(/^(.*?)( \d+)(\.[^.]+)$/)
      next unless match

      original_name = "#{match[1]}#{match[3]}"
      duplicate_name = file

      if files.include?(original_name)
        duplicates << [File.join(dir, original_name), File.join(dir, duplicate_name)]
      end
    end
  end

  duplicates
end

# Helper to format size nicely
def human_size(bytes)
  units = ['B', 'KB', 'MB', 'GB', 'TB']
  return '0 B' if bytes == 0
  exp = (Math.log(bytes) / Math.log(1024)).to_i
  "%.2f %s" % [bytes.to_f / 1024**exp, units[exp]]
end

# Recursively collect all files by directory
files_by_dir = Hash.new { |h, k| h[k] = [] }

Find.find(directory) do |path|
  next unless File.file?(path)
  dir = File.dirname(path)
  name = File.basename(path)
  files_by_dir[dir] << name
end

# Find duplicates
duplicate_pairs = find_duplicates(files_by_dir)

# Track total size
total_duplicate_size = 0

# Verify content and act; preview is the default
duplicate_pairs.each do |orig_path, dup_path|
  if File.size(orig_path) == File.size(dup_path) &&
     Digest::SHA256.file(orig_path) == Digest::SHA256.file(dup_path)
    size = File.size(dup_path)
    total_duplicate_size += size

    puts "Match: #{orig_path} <=> #{dup_path} (#{human_size(size)})"

    if options[:delete]
      File.delete(dup_path)
      puts "  Deleted: #{dup_path}"
    end
  end
end

# Review every reported pair before rerunning with --delete.

# Final total
puts "\nTotal duplicate size: #{human_size(total_duplicate_size)}"

It's pretty meh from many points of view, for example as I love ActiveSupport, the generated method human_size(bytes) is just horrid. I could have generated this using standard *nix tools + some bash, but I went with Ruby as it is much more familiar and easier to grok for me.

The script was generated in around 15 minutes, after a couple of prompt iterations - now, if I were to write this from scratch, knowing myself - this would have been a small gem and I'd probably have spent some time getting the recursive directory checks right.

At the end of the day - I created something useful for myself, which was rather easy to check since it was "coded" in Ruby. If I were to write this from scratch this experience would have been completely different.

Cognitive debt

There's also a cognitive dissonance about this: why didn't I just write it myself? it would have been fun, I just wanted to save some time, but at what cost?

This is why the whole LLM human assisted code generation is not a full boon - it's like cheating your brain, not learning anything, and it also leaves you in a state of dissonance.

Are LLMs going away? No. Will I stop using them? No. I just need to fix my cognitive dissonance when it comes to their use and in the process, avoid rotting my brain, after all, people will start calling me soon enough an "analogue programmer".

Ruby meets LISP: Unveiling alien tech at Friendly.rb's lightning talk

2025-07-06T08:37:13Z

Originally published after the 2023 Friendly.rb conference in Romania, this is an archival account of that talk.

At the Friendly.rb conference in Romania, I explored an experimental blend of Ruby and the Lisp family, implemented here through Clojure. This journey was more about embracing the spirit of experimentation intrinsic to Ruby, rather than direct comparison.

A big shoutout to Jakob , whose suggestion that I do a lightning talk was a catalyst for my participation. His encouragement led me to share my explorations with fellow Ruby enthusiasts.

One of my personal highlights at the conference was Naijeria Toweett's talk, "React-ing to Rails: Why Ruby on Rails is the Best Stop for Web Developers." Her transition into tech as a mother and a problem solver was not only inspiring but also infused with humor and warmth, bringing a delightful human touch to the technical world. For those curious to experience her engaging storytelling and insightful journey with Ruby on Rails, Naijeria's full presentation is available online .

In my presentation, I delved into Ruby's playful side by contrasting its syntax with features common to Lisp-family languages. A pivotal aspect of my talk was utilizing JRuby to integrate Ruby on Rails with Clojure, demonstrating Ruby's creative possibilities. This integration owes much to Charles Oliver Nutter , the maintainer of JRuby. His work in maintaining this crucial bridge between Ruby and Java ecosystems has been indispensable for the Ruby community. You can watch my talk here .

And here it is: app/views/articles/index.html.clj in all its glory:

(html
  [:main
    [:section {:id "ruby-lisp-alien-tech"}
      [:h2 "Ruby & the LISP Alien Tech"]
      [:p "When we talk about the world of programming languages, two stand out in their unique ways: Ruby, "
          "with its elegant syntax and Rails powerhouse, and LISP, the ancient language known for its "
          "code-as-data philosophy. The connection? Both embody the spirit of making the impossible possible. "
          "Join us as we delve into the mysteries of Ruby and LISP and uncover the alien tech within."]
      [:img {:src "https://www.lisperati.com/lisplogo_warning2_256.png", :alt "LISP Alien Tech Illustration"}]]

    [:section {:id "s-expressions"}
      [:h2 "What are S-expressions?"]
      [:p "S-expressions, or symbolic expressions, are a fundamental part of the LISP (LISt Processing) "
          "programming language. They are used to represent both data and code. An S-expression can be an "
          "atom or a list. At its core, an S-expression is a way to represent nested list data in a uniform "
          "manner."]
      [:figure
        [:img {:src "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAVUA", :alt "S-expression diagram (illustrative truncated data URI)"}]
        [:figcaption "A visual representation of S-expressions."]]]])

The base64 image data above is intentionally truncated for illustration, so that excerpt is not directly runnable.

The focus was on Clojure's Hiccup library to dynamically render HTML in a Rails application. This required creating a custom ActionView::Template handler in Rails to process Clojure's code. More than a technical exercise, this project was about exploring the contrasts between OOP and functional paradigms, particularly in Clojure. It was purely an exploration, having no practical purpose other than demonstrating Ruby's flexibility and encouraging paradigmatic curiosity.

At the time, I was already revving up for the following year’s Friendly.rb conference, it’s not just the anticipation that’s buzzing — it's the reminder of how electrifying the Ruby community truly is. These events are like the ultimate sandbox for grown-up tech enthusiasts: a place to share, learn, experiment, and sometimes, just revel in the camaraderie of like-minded tinkerers.

Bonus: if you're already marking your calendar and planning your tech adventures, tickets were already on sale when this was published.

I extend my kudos to the Friendly.rb team - Adrian , Lucian , Jakob , Alex , and Stefan - for creating a platform where learning and community can thrive.

Resources

Source code repository: Weird Ruby on GitHub
Learn about Clojure: Clojure Official Site
Hiccup library: Hiccup on GitHub
For Clojure & Leiningen: Leiningen
About JRuby: JRuby Official Site

Programming archaeology: PHP's dollar sigil

2025-07-05T21:20:05Z

I started out with Java as my professional language and before I discovered Ruby, PHP was my main programming language of choice for new projects. This was probably six to seven years ago or more. I had some pretty good times with CodeIgniter [0] and various libraries like HHMVC [1].

In any case, I digress - even back then the most striking feature of its syntax was the dollar sign prepended to variables which made me think the aesthetics of the language were sub-par or at least annoying. Clearly it did not stop me from writing lots of apps in PHP since it was more of a small annoyance, if you will, something debatable mostly for scholastic purposes.

Recently the question popped into my mind: "What is the history of the dollar sign, and why is it there?" - so like every good question I started to Google my way into some answers:

From Perl to PHP

First influence - Perl:

Perl might have inherited this from shell tools like awk et al. hence:

A Quora answer provided a useful anecdote that further connected the ideas above:

Sigils in Perl

From this we find out that $, @ and % are actually called sigils [2] in computer programming. Next stop was to see what these sigils indicated in Perl:

Scalar values are always named with '$', even when referring to a scalar that is part of an array or a hash. The '$' symbol works semantically like the English word "the" in that it indicates a single value is expected.

  $days               # the simple scalar value "days"
  $days[28]           # the 29th element of array @days
  $days{'Feb'}        # the 'Feb' value from hash %days
  $#days              # the last index of array @days

Entire arrays (and slices of arrays and hashes) are denoted by '@', which works much as the word "these" or "those" does in English, in that it indicates multiple values are expected.

  @days               # ($days[0], $days[1],... $days[n])
  @days[3,4,5]        # same as ($days[3],$days[4],$days[5])
  @days{'a','c'}      # same as ($days{'a'},$days{'c'})

Entire hashes are denoted by '%':

  %days               # (key1, val1, key2, val2 ...)

via http://search.cpan.org/~shay/perl-5.24.1/pod/perldata.pod#Variable_names

A Ruby comparison

Very interesting and they remind me of Ruby's shorthand or general delimited input:

%w(foo bar) # => ["foo", "bar"]
# %r() is another way to write a regular expression.
# %q() is another way to write a single-quoted string (and can be multi-line, which is useful)
# %Q() gives a double-quoted string
# %x() is a shell command
# %i() gives an array of symbols (Ruby >= 2.0.0)
# %s() turns foo into a symbol (:foo)

Conclusion

Conclusion? The dollar sign for variables in PHP is actually a vestigial sigil since compared to Perl there aren't any for arrays and hashes.

[0] - https://codeigniter.com [1] - https://github.com/jenssegers/codeigniter-hmvc-modules [2] - https://en.wikipedia.org/wiki/Sigil_(computer_programming)

This historical chain is reconstructed from secondary and Q&A sources; it is a plausible trail, not primary-source proof of PHP’s design lineage.

Multiple data stores and eventual consistency using micro-services

2025-07-05T21:20:05Z

There are cases where ownership of the data consumed by a fleet of microservices is distributed across several systems of record. Derived data is then scattered across multiple storage solutions, each designed to solve a specific problem using a subset of it. It may be mirrored and synchronized into a specific format (consider a graph database), or enriched with features that exist only in another store (consider a relational database with custom metadata). These read models can derive from relational or document databases, resources exposed through APIs, or a mixture of them.

The question in this case is how to achieve eventual data consistency across all the data stores keeping in mind that source-of-truth ownership is distributed across multiple data stores and third-party APIs, each with its own set of shortcomings. Moreover let's assume that consolidating them into one data store is not an option - in this specific case a strategy within a set of constraints is required in order to achieve an adequate level of consistency which can guarantee the correct resolution of end-user specific use-cases.

First it becomes clear that the criteria for each data store's consistency need to be properly defined - how fresh must the data be? does access require bidirectional synchronization—reads and writes—or is it just a read model within a specific type of data store to optimally solve a problem e.g. moving the relations between users into a graph database in order to easily make connections between them and generate insights that can then be easily consumed through a micro-service by various clients (mobile, web apps, etc.)

Read-only consistency

The simplest case is a read-only mode with little or no metadata. It is also important to know whether the metadata is encapsulated or leaks into other microservices’ business logic. If we're talking about the former then the rules for data freshness are dictated by its consumers.

Bidirectional consistency

The next one is when we have to deal with bidirectional consistency i.e. a client updates something in our data store and we need to sync that back with all the relevant systems of record. Now, this becomes quite problematic, because we have a dependency tree with side-effects leaking on each leaf. Existing criteria dictated by the consumers will thus require syncing the data to lowest acceptable interval, otherwise we will break the consistency contract we have with our clients. This becomes quite complex with metadata that is shared between multiple micro-services.

Shared metadata and queues

What about metadata? This is now a full-fledged cross-cutting concern that becomes dissonant with itself as it needs to be synced in multiple places and via different protocols (think about having similar metadata in a graph database and a relational database). Optimally, metadata that cuts across multiple microservices should reside in one system of record but let's say this is not an option.

This quickly transforms into an aching architectural issue - the solution resides not in a shared data store but within a shared mechanism of keeping track of these changes. One solution could emerge in the form of queues with ack/retry capability backed by persistence (something à la RabbitMQ, Kafka, etc.). It is now self-evident that this adds another complication: how do we deal with persistent events in the queues that are now inconsistent due to how much time they resided (a simple example would be a set of unacked events that after some time "T" become invalid as the record/object they have a reference to doesn't exist anymore) as a result: this will require another mechanism to drop those events from the queues or add another high level abstraction leak as the clients will have to deal with the issues of out-of-date data.

Eventual consistency in a complex system with distributed systems of record with an added complication of cross cutting metadata within a fleet of micro-services is quite an interesting problem to solve - in its most basic form we deal with a graph of (inter)dependencies that should govern the orchestration of both the micro-services and the syncing of the various data stores.

Finally, the solution would emerge from the graph of (inter)dependencies in the form of an attached mechanism which abstracts the distributed ownership behind one coherent view that stays within the confines of its consumers, thus delivering the expected business value on all fronts.

More information:

Moving from iTerm2 to Kitty for simplicity and performance

2025-07-06T08:38:30Z

I love iTerm2, but it can be sluggish sometimes on my old late 2016 MacBook Pro. Plus, many of its features I never use. I had tried Alacritty before, but making it look and act like iTerm2 was a no-go. This time, I tried Kitty, and within two hours of work, it looked and behaved just like my iTerm2 configuration. This exploration was fueled by a performance comparison I came across that piqued my interest.

To really put Kitty to the test, I used my older MacBook Pro, deliberately looking for CPU usage spikes via fan noise and Activity Monitor. My "benchmark" was simple: opening an 800-line Rails schema and scrolling through it using Vim's Shift + ]. Unlike iTerm2, which often caused my fans to ramp up, Kitty handled the same tasks with significantly less strain on the CPU.

I quickly realized that syntax highlighting was a major bottleneck. To address this, I switched to vim-polyglot for faster Ruby syntax highlighting. The improvement was modest but noticeable. In a deliberately unrealistic test where I scrolled through the file quickly, latency felt lower and I did not notice dropped frames. These are anecdotal observations from my machine, not controlled benchmarks.

Configuration tweaks

To further optimize Kitty, I made several configuration tweaks: - Integrated it into my dot-files as a git submodule . - Set the text_composition_strategy to legacy to emulate the thin strokes from iTerm2. You can find the setting here . - Used the Monokai Pro theme from kitty-themes for a familiar and visually appealing look. - Benefited from Kitty leveraging vector CPU instructions, which can enhance its overall performance .

My Kitty configuration explained

Here are some specific Kitty configurations I used and what they do:

vim:fileencoding=utf-8:foldmethod=marker
# Ensures that the configuration file is encoded in UTF-8 and uses marker-based folding.

include ./theme.conf
# Includes an external theme configuration file for consistent theming.
font_family Berkeley Mono Variable
# Sets the font to Berkeley Mono Variable.
font_size 16.0
# Sets the font size to 16.0 points.
text_composition_strategy legacy
# Uses the legacy strategy for text composition, emulating thin strokes similar to iTerm2.

enable_audio_bell no
# Disables the audio bell to prevent sound alerts.
visual_bell_duration 0.0
# Sets the visual bell duration to zero, effectively disabling it.

iTerm2 versus Kitty terminal rendering comparison

Figure: iTerm2 versus Kitty with my configurations.

If Kitty performs well under these stressful and unrealistic contexts, it will certainly be even faster on my M1 Pro MacBook Pro. Plus, the switch was a fun and rewarding project. Kitty not only matches the appearance and functionality of iTerm2 but also offers a performance boost that makes my old MacBook Pro feel more responsive and efficient.

Overall, I highly recommend giving Kitty a try if you're looking for a terminal emulator that combines simplicity and performance.

Making Rails asset pipeline faster

2025-07-05T21:20:05Z

This article reflects the 2016-era Rails asset pipeline—Ruby Sass, libsass, Compass, therubyracer, and Node.js 6—and is not current Rails asset guidance.

We all know that for a rather large Rails app with a substantial front end, the asset pre-compilation and more importantly - development mode changes are far from instantaneous.

The front-end we're referring to is the kind that makes heavy use of sass, sass libraries (Compass, Bourbon, etc.) and transpiled JavaScript languages (like the old CoffeeScript, ES6, etc.)

Replacing Ruby Sass with libsass

On the Sass front for quite some time there's a pure C/C++ implementation of the Sass CSS precompiler: libsass . Clearly, being implemented in C/C++ this means it should run several times faster than the Ruby implementation.

All we need is a gem that uses it: enter sassc-rails which is a drop-in replacement for the sass-rails gem.

How fast is sassc-rails compared to the vanilla gem in the real world? (benchmarks straight from their repo)

# Using sassc-rails
[1] pry(main)> Benchmark.bm { |bm| bm.report { Rails.application.assets["application.css"] } }
       user     system      total        real
   1.720000   0.170000   1.890000 (  1.936867)

# Using sass-rails
 [1] pry(main)> Benchmark.bm { |bm| bm.report { Rails.application.assets["application.css"] } }
       user     system      total        real
  7.820000   0.250000   8.070000 (  8.106347)

Not orders of magnitude faster, but then again a roughly 4.5x improvement is not bad at all.

The only issue with this is that it doesn't fully work with the usual sass gems like Compass and more i.e. before using it in production make sure it can actually compile your scss files without issues.

To help with that you can check the Sass Compatibility website and run your app with the gem installed in a different branch to test things out.

Compass intermission

What grinds my gears is that Compass doesn't work at all with sassc-rails:

Also as a side note Compass seems, well, kinda dead:

I think I'm going to migrate my front-ends that still use Compass to Bourbon and maybe autoprefixer-rails

Replacing the JS transpiling/minification/etc. with mini_racer

The problem with therubyracer is that it uses version ~> 3.16.14.0 of libv8 ("a gem for distributing the v8 runtime libraries and headers in both source and binary form") whereas mini_racer uses ~> 5.1 which as one might expect is quite faster than the former.

Some quick benchmarks from their repository:

$ ruby bench_uglify.rb

Benching with MiniRacer
MiniRacer minify discourse_app.js 13813.36ms
MiniRacer minify discourse_app_minified.js 18271.19ms
MiniRacer minify discourse_app.js twice (2 threads) 13587.21ms

Benching with therubyracer
MiniRacer minify discourse_app.js 151467.164ms
MiniRacer minify discourse_app_minified.js 158172.097ms
MiniRacer minify discourse_app.js twice (2 threads) - DOES NOT FINISH

Killed: 9

Here we are talking about roughly a 9–11x improvement i.e. really nice gains and thus an order of magnitude faster. On the compatibility side this seems to be a drop-in replacement i.e. so far in the apps I've added it in the Gemfile there were no issues whatsoever.

Alternative to mini-racer for best possible performance

Sprockets uses ExecJS which “picks the best runtime available to evaluate your JavaScript” this means that if you don't mind having an extra dependency installed you can just use Node.js 6.x to get the maximum performance.

Since I deploy my assets by precompiling them locally I just installed Node.js 6.2.0 via brew brew install node and ran time rake assets:clobber assets:precompile on a 2K lines CoffeeScript JS file. Without further ado, here are the results:

Runtime	Timing
node.js 6.2.0	rake assets:clobber assets:precompile 7.30s user 1.27s system 102% cpu 8.358 total
mini-racer with libv8 5.x	rake assets:clobber assets:precompile 14.96s user 1.20s system 101% cpu 15.943 total

That's another 2x speed-up! Also, I tried it with 10K lines of CoffeeScript - in this case mini-racer didn't even finish.

Kudos goes to @attilagyorffy for pointing this out.

Should I use these in production?

In a set-up where the assets are pre-compiled locally then uploaded to the actual VM this is not a big issue i.e. if something fails just revert to the original gems.

Mini-racer looks rock solid so far whereas sassc-rails still has issues with some libraries i.e. not ready for production in all use-cases yet.

If you don't mind installing node.js and want maximum performance then by all means do it since it works flawlessly with ExecJS.

In the optimal case where you can integrate both into your Gemfile you will get quite a nice boost during deploys and more importantly: during development (in apps with large sets of assets of course).

macOS Sierra upgrade from a developer's perspective

2025-07-05T21:20:05Z

Historical note: these are macOS Sierra 10.12-era procedures. SIP paths, Karabiner, Notes, and photoanalysisd behavior may differ on current macOS releases.

Most developers (myself included) usually wait for the point one release of the next major macOS upgrade. This is mostly in order so that all the related tools/applications maintainers will have time to upgrade and iron out their bugs/issues with the new OS.

Since I use my Mac mostly as a glorified *nix replacement, the GUI applications are scarce (notably: iTerm , Paw , Postgres.app , Xcode and a couple of small utilities) i.e. the bulk of my development is dependent on Homebrew working correctly + the good old RVM .

All of these work flawlessly under Sierra, one just has to remember to update them beforehand via:

$ brew update
$ rvm get stable

Afterwards a clean output from brew doctor should fix whatever potential issues remain.

The main issues after the OS upgrade were, ironically, not the apps/utilities but the crushingly slow default values for KeyRepeat, a pink external EIZO display, the Notes.app crashing like nuts and finally some minor performance tweaks (mostly for aesthetics)

Fixing slow key repeat

If you use vim in a terminal you'll quickly realize that the navigation is back to slow as heck. That's due to the KeyRepeat values. In El Capitan this could be fixed easily via Karabiner but for 10.12 their developers have a wip Karabiner-Elements which is useless at this point (at least for me as it tells that I should edit JSON files).

Well, no thank you good sirs: if I'm going to edit config files, I'd rather do it directly at the OS level.

After some testing around I got back the fast and snappy vim scroll/navigation via:

$ defaults write NSGlobalDomain KeyRepeat -int 1
$ defaults write NSGlobalDomain InitialKeyRepeat -int 12

Note: these can be reset back to their default via:

$ defaults delete NSGlobalDomain KeyRepeat
$ defaults delete NSGlobalDomain InitialKeyRepeat

In order for them to take effect you can just log out or restart your Mac.

Fixing my pink external EIZO display

This was rather easy but tedious: it basically boils down to repeating the same steps again from Mathew's article i.e.:

Disable macOS's SIP by booting into recovery mode (using Command-R whilst rebooting your mac and then running csrutil disable in the terminal).

Download the linked Ruby script and run it via ruby patch-edid.rb. It will generate a directory.

Move the directory into (back-up the old one if it exists): /System/Library/Displays/Contents/Resources/Overrides

Then you can restart again into recovery mode and re-enable SIP by running csrutil enable into the terminal.

After all this: my external LCD was crystal clear and NOT pink anymore.

Notes.app crashing and minor performance tweaks

The first one is simple: just disable/enable the iCloud Notes syncing.

Regarding the second one you can tick reduce transparency and motion in the Accessibility section in Settings (this should offload the GPU if you have an older Mac with Intel graphics and as aesthetics and UX go, I'm not a fan of over-the-top animations and transparency).

Other issues

Wi-Fi not working

Rachel pointed out her Wi-Fi wasn't working anymore. The fix: after posting the issue on Apple forums someone suggested this article that finally fixed it.

I also had a small problem with it but it quickly went away by turning the Wi-Fi off and then back on. In any case hopefully this will ease the upgrade for someone.

Conclusion

Bonus: right after the upgrade prepare for 100% CPU usage on all logical cores for ~ one hour or less, the culprit will be photoanalysisd:

In the end, the upgrade wasn't painless; El Capitan went more smoothly by comparison but at least I removed an extra dependency - I no longer need to have Karabiner running in the background and somehow it feels a tad faster even whilst the memory pressure is now lower.

Credits

Keep your Rails logs free of unwanted noise

2025-07-05T21:20:05Z

I like to use Rollbar 's default plan for small apps or prototypes that are works in progress. Getting production exceptions in my inbox can be quite useful but most of them are actually 404s - sure there are a multitude of ways for filtering out the noise (Fail2Ban , hand-written iptables rules , etc.)

Historical note: these examples reflect an older Rails and Ubuntu 14.04-era deployment, so current Rack::Attack and infrastructure APIs may differ.

The main idea here is to filter as much of the noise in Rails logs with simple enough changes — security is a completely different topic (though some of the tools do touch on that realm too).

Nginx

First thing I've observed was that my app was getting scanned via the IP and not the domain name — so first the fix comes as a configuration change in nginx to enable responses only via the app's host:

server {
  listen 80;
  server_name {the-ip-address};
  return 404;
}

I'm not really sure whether I should use 404 or 403 — Not Found sounds correct since one should not access the app via its IP but Forbidden is somewhat equally suitable — the resource is here but you cannot access it via the server's IP.

This single configuration change reduced the logging noise by about 200 daily faux-requests — which is quite nice.

Rack::Attack

Next stop: automatic scans for WordPress vulnerabilities — lots and lots of requests for wp-admin and wp-login — just ghastly.

How can we fix this? We get down on the application level i.e. Rack.

The idea is simple: put a Rack middleware in front of the chain that can just drop all those pesky WP scans: Rack::Attack

Installation is simple: add the gem to your Gemfile, create a config file like /config/initialisers/rack_attack.rb and add:

# After 1 blocked request in 10 minutes, block all requests from that IP for 1 day.
Rack::Attack.blocklist('fail2ban pentesters') do |req|
  # `filter` returns truthy value if request fails, or if it's from a previously banned IP so the request is blocked
  Rack::Attack::Fail2Ban.filter(
    "pentesters-#{req.ip}",
    maxretry: 1,
    findtime: 10.minutes,
    bantime: 1.day
  ) do
    # The count for the IP is incremented if the return value is truthy
    req.path.include?('wp-admin') ||
    req.path.include?('wp-login')
  end
end

Any request to /{wp-admin | wp-login} will translate into an instant one-day ban for that IP. Clearly you could do this using Fail2Ban but Rack::Attack comes with other niceties too and it ticks the simple checkbox whilst being more portable than Fail2Ban.

The final step is to actually use this middleware by prepending it in config.ru:

require ::File.expand_path('../config/environment',  __FILE__)

use Rack::Attack
run YourApp::Application

Why in config.ru and not in the config files of Rails? Mostly because of semantics — it's not related to the business logic of the app and it makes it explicit that's the first Rack middleware a request going through nginx will hit.

After all of this is set up — a simple request to '/wp-admin' will result in a 403 with the Forbidden message and a one-day ban.

Conclusion

	404 exceptions/day
before	220 to 240
after	10 or fewer

and this without completely turning off 404 exceptions.

Filtering scanner noise is not access control. A one-request, one-day IP ban can also affect people behind NAT or a shared IP, and multi-instance deployments need shared state plus edge or global controls for consistent enforcement.

Kamal, Rails deployments, and Rega turntables

2026-03-22T19:38:10Z

Lately I've started to put my turntable back into working order. It's been disconnected from my main audio chain for about five years. The TT is a Rega RP3 with a bog-standard Rega Carbon cartridge. Why now one might ask? It wasn't my top priority and streaming Spotify to the WiiM Mini then via a DAC directly into my NAD power amplifier was good enough.

Yet, I started missing my records. I mean I still have them, I can still enjoy their tactility, art and smell, but not their sound. I missed the limits imposed by listening to vinyl: you have to carefully pick your album and then commit to listening to the whole thing, more or less.

Anyway - after some cabling around, I managed to make it work and even better: improve its specs. It went from 33 1/3 rpm +0,57% to just +0,07%. The records sound great and I can now enjoy them in their full glory whilst following the rite of listening just like in Murakami's books .

Now, what's the connection with Kamal and Rails ? I've been using my blog to test out various Ruby/Rails changes, practically there's no need to have a full CMS for something which you can write using HTML and a sprinkle of CSS and JavaScript.

The crux of my blog is to experiment and enjoy programming in a restricted way. It's a blog at the end of the day so it does need a CMS that means CRUD resources, feeds, SEO, partials, caching, public routing, etc. all within a dynamic language like Ruby and aided by Rails.

From Capistrano to Kamal

As any Rails app it does need to be deployed somewhere and somehow. Back in the day I was using Capistrano to deploy to VMs from Linode, Hetzner et al. Then there was a large portion where I deployed to the Heroku free tier behind Cloudflare, but once that was gone I went back to VMs.

Capistrano is considered "old school", non-idempotent, etc. Nowadays, it still works but Rails now comes with a Dockerfile and direct support for Kamal: the Docker-based deployment of choice for Rails apps (if you want to use it).

The Rails app is quite small and the initial version of Kamal required a docker registry to be able to deploy to a VM. This wasn't a big deal as you can create a private Docker registry for free in many places including Docker itself (this is what I used). Yet for a small app this was annoying for me since I now require an account which is permanently linked to my deploys.

Thankfully as Kamal evolved the support for a local registry was added and this fixed the issue. What happens now is that Kamal starts a local registry container on your machine and forwards the remote server to it over SSH.

This works pretty great in practice: my deploys are not dependent on an account anymore, however there is a small caveat: tunnelling via SSH can be slow. I have my app in an Oracle Cloud Always Free instance, using its Arm-based Ampere A1 Compute offering. On this server and connection, a fresh deploy that transfers the 130MB+ compressed Docker image over the SSH tunnel has stayed below 300KB/s. That is a small price to pay in my case, but it is an observation from this setup rather than a universal Kamal limit.

A smaller Docker image

This is probably a good mid-point to share my optimized dockerfile :

# syntax = docker/dockerfile:1
ARG RUBY_VERSION=4.0.6
FROM ruby:$RUBY_VERSION-slim AS base
WORKDIR /rails
ENV RAILS_ENV="production" BUNDLE_WITHOUT="development:test" BUNDLE_DEPLOYMENT="1"
RUN gem update --system --no-document && gem install -N bundler

FROM base AS build

RUN apt-get update -qq && apt-get install --no-install-recommends -y build-essential pkg-config libyaml-dev libsqlite3-dev && rm -rf /var/lib/apt/lists /var/cache/apt/archives

COPY --link Gemfile Gemfile.lock ./

ENV BUNDLE_PATH="/usr/local/bundle" PATH="/usr/local/bundle/bin:$PATH" BUNDLE_JOBS=4 BUNDLE_RETRY=3
RUN bundle install && rm -rf ~/.bundle/ $BUNDLE_PATH/ruby/*/cache $BUNDLE_PATH/ruby/*/bundler/gems/*/.git

COPY --link . .

RUN chmod +x bin/*
RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile

FROM base AS runtime

RUN apt-get update -qq && apt-get install --no-install-recommends -y libsqlite3-0 && rm -rf /var/lib/apt/lists /var/cache/apt/archives

ENV BUNDLE_PATH="/usr/local/bundle" PATH="/usr/local/bundle/bin:$PATH"

COPY --from=build /usr/local/bundle /usr/local/bundle
COPY --from=build /rails /rails

RUN useradd rails --create-home --shell /bin/bash && mkdir -p /data /rails/db /rails/tmp /rails/log /rails/public && chown -R rails:rails /rails/db /rails/tmp /rails/log /rails/public /data
USER rails:rails

ENV DATABASE_URL="sqlite3:///data/production.sqlite3" RUBY_YJIT_ENABLE="1"

ENTRYPOINT ["/rails/bin/docker-entrypoint"]

VOLUME /data
EXPOSE 80
CMD ["bundle", "exec", "puma", "-C", "config/puma.rb"]

I have tried to reduce its size so that initial hit will be smaller plus I like to optimize things i.e. I still think the whole image at over 130MB is a bit too much.

Going back to my Rega turntable, its cartridge, the Rega Carbon, is actually an Audio-Technica AT3600L , a moving magnet one - which is decent but also the minimum when it comes to sound quality. I do want to upgrade it to something like an Ortofon or a Nagaoka MP-150/300 and whilst they are pricier, the issue is that I have to adjust them properly after installing them.

Rega recently created the Carbon Pro which is a direct upgrade to the Carbon but without removing the whole cartridge—just the stylus and its housing. This is straightforward as it doesn't require me to go crazy trying to adjust a new cartridge from scratch.

Replacing Docker Desktop with Colima

Similarly, Kamal requires Docker and the simplest way on macOS is via Docker Desktop which is fine but also kind of an annoyance i.e. I want to get rid of it without dropping Kamal.

Just as a refresher this is how Kamal works more or less:

Local machine
  kamal CLI
    |-- uses Docker/Buildx to build images
    |-- may build locally, multi-arch, or with a remote builder depending on config
    |-- uses SSH to run Docker commands on servers
    |-- can run/use a local registry at localhost:5555

Remote servers
  Docker Engine
    |-- pulls image from registry
    |-- runs app/proxy/accessory containers

I can replace most of Docker Desktop by running:

brew install docker docker-buildx

But this does not give me a running Docker daemon; this is where Colima jumps in, as it provides: - a Linux VM with Docker Engine (dockerd) - a Docker context/socket (docker context use colima) - runtime for Buildx builder containers - runtime for local registry container (localhost:5555 flow)

A nuance to note:

On some Colima setups, buildx may need to be installed or exposed as a Docker CLI plugin before docker buildx works properly. Also, if your local-registry setup needs special Docker daemon settings, such as insecure-registries or registry mirrors, Colima supports that too through its Docker configuration. In my case the simple setup was enough, but it is worth checking the Colima FAQ if your machine behaves differently.

Before removing Docker Desktop, preserve or migrate any local images, volumes, and Docker contexts you still need; uninstalling it can otherwise discard local data. After I fully removed Docker Desktop from its own UI (this felt quite nice), all I had to do was:

colima start --arch aarch64 --vm-type vz --mount-type virtiofs --cpus 1 --memory 1
docker context use colima

Then verify that everything works correctly:

colima status
docker context ls
docker context show
docker info
docker run --rm hello-world
docker buildx ls

And finally just ran kamal deploy and it worked: fast deploys without Docker Desktop. This is just awesome and it finally feels like good old Capistrano without the drawbacks.

Just like the Carbon Pro, Colima adds a container runtime without breaking Kamal whilst removing the icky Docker Desktop behemoth.

Credits

JRuby, RVM and Vim walk into a (performance) bar

2025-07-05T21:20:05Z

I'm not sure why RVM is still my default Ruby version manager, but the issue at hand should be reproducible on rbenv too.

Historical note: this article reflects a Vim 8.0, JRuby, RVM, and macOS system Ruby setup from 2017; versions and defaults differ on current macOS systems.

Let's add a bit of context to this: we have an API written in Ruby and running on JRuby i.e. via JVM which implies slow start-up times compared to CRuby (yes, even with export JRUBY_OPTS='--dev'). I use Vim 8.0.502 which of course comes by default bundled with Tim Pope's vim-ruby .

Profiling Vim startup

The problem: since I've switched to JRuby I started to notice a slowdown whilst working in Vim with .rb files. I did not pay too much attention to it at first (read: for almost a month) but today it really started to bug me. I had no idea what was causing the slowdown so I tried Vim's trusty command-line option:

vim --startuptime profile-data app/controllers/application_controller.rb

which yielded (edited for brevity):

104.316  002.877  002.877: sourcing /usr/local/share/vim/vim80/syntax/ruby.vim
1228.691  1123.486  1123.486: sourcing /usr/local/share/vim/vim80/ftplugin/ruby.vim
1229.935  000.686  000.686: sourcing /usr/local/share/vim/vim80/indent/ruby.vim
{ edited }
1273.618  043.838: opening buffers
1274.471  000.853: BufEnter autocommands
1274.475  000.004: editing files in windows
1274.924  000.449: VimEnter autocommands
1274.932  000.008: before starting main loop
1299.500  024.568: first screen update
1299.501  000.001: --- VIM STARTED ---

Over one second to open a simple Ruby file? ouch!

The relevant line in that file is:

1228.691  1123.486  1123.486: sourcing /usr/local/share/vim/vim80/ftplugin/ruby.vim

Why are we spending one second in ruby.vim? The answer is in this function which gets executed before opening a .rb file:

function! s:query_path(root) abort
  let code = "print $:.join %q{,}"
  if &shell =~# 'sh' && empty(&shellxquote)
    let prefix = 'env PATH='.shellescape($PATH).' '
  else
    let prefix = ''
  endif
  if &shellxquote == "'"
    let path_check = prefix.'ruby --disable-gems -e "' . code . '"'
  else
    let path_check = prefix."ruby --disable-gems -e '" . code . "'"
  endif

Note: ftplugin stands for filetype and not FTP - so yes, this logic is required.

After all of this I did one more test: using top in another tmux window I could actually see the Java process running after Vim therefore the issue was trivial: vim-ruby was using JRuby.

Forcing vim-ruby to use CRuby

The logical next step: instruct Vim to use CRuby if RVM with JRuby is detected. After some searching—including a historical Google+ link that is now unavailable— the solution was an appendix to .vimrc:

if !empty(matchstr($MY_RUBY_HOME, 'jruby'))
  let g:ruby_path = '/usr/bin/ruby'
endif

Basically if RVM has set up JRuby already instruct vim-ruby via its helpful ruby_path config to use the system Ruby (on the macOS version used for this 2017 test, CRuby 2.0.0p648)

Results

Results after the fix:

104.643  002.876  002.876: sourcing /usr/local/share/vim/vim80/syntax/ruby.vim
106.938  001.369  001.369: sourcing /usr/local/share/vim/vim80/ftplugin/ruby.vim
108.062  000.622  000.622: sourcing /usr/local/share/vim/vim80/indent/ruby.vim
{ edited }
152.700  044.957: opening buffers
153.389  000.689: BufEnter autocommands
153.394  000.005: editing files in windows
154.086  000.692: VimEnter autocommands
154.092  000.006: before starting main loop
178.172  024.080: first screen update
178.174  000.002: --- VIM STARTED ---

~200ms => much better.

Interesting links - Is logging a "code smell" ?

2025-07-05T21:20:05Z

I was reading this article , and it raises quite an unexpected question - "Can we consider logging as a code smell"?

Clearly - the answer is more nuanced than that and whilst I do enjoy the event bus approach from the article - that seems like overkill for most applications.

It's interesting that Aspect Oriented Programming is mentioned but not in a positive light and I resonate with that to a certain extent - especially in Java but in the Ruby world this is quite easy to implement - actually no one even calls it AOP (most likely because it is not within the pure definition of it) it's just a neat little feature of ActiveSupport : more precisely ActiveSupport::Notifications.

To me that's quite similar to the implementation in the original article - it just comes under the "instrumentation API for Ruby" moniker.

Instrumentation with ActiveSupport::Notifications

A simple example would look like:

ActiveSupport::Notifications.instrument('some_action_that_requires_instrumentation') do
  run_the_action
end

In some other part of our logic - preferably in a config file we can subscribe to those events:

ActiveSupport::Notifications.monotonic_subscribe('some_action_that_requires_instrumentation') do |name, start, finish, id, payload|

  # According to the docs we get a handy set of meta information:
  #
  # name         => String, name of the event (such as 'some_action_that_requires_instrumentation' from above)
  # start          => Monotonic time, when the instrumented block started execution
  # finish        => Monotonic time, when the instrumented block ended execution
  # id              => String, unique ID for the instrumenter that fired the event
  # payload    => Hash, the payload

  # here we could implement our logging and instrumentation (Librato & friends)

end

Credits

How to reduce the size of your VMs (macOS Update)

2025-07-05T21:20:05Z

Lately I'm also running macOS virtualized for testing various apps. After some heavy usage the same problem popped up: the .vmdk uses way too much space on my quite small 256GB SSD. Currently is at around 70GB.

The process is similar to what I did on Windows and Linux i.e. write a null file that is erased at the end then use the command-line tools to compact the .vmdk and reclaim space (the example is specific for VMware Fusion).

Before performing these disk operations, take a verified backup or snapshot, shut down the VM correctly, and confirm that the virtual disk is thin-provisioned and that adequate free space is available. Writing from /dev/zero intentionally exhausts the guest’s free space; understand and monitor the operation before proceeding.

Without further ado:

Step one

Fill up all the empty space with 0x00

$ cat /dev/zero > zeroed_empty_space; rm zeroed_empy_space

In case you're wondering what /dev/zero does:

/dev/zero is a special file in Unix-like operating systems that provides as many null characters (ASCII NUL, 0x00) as are read from it. One of the typical uses is to provide a character stream for initializing data storage.

Step two

VMWare Fusion is installed by default in /Applications/VMware Fusion.app so you just have to run:

$ cd '/Applications/VMware Fusion.app/Contents/Library/' 
$ vmware-vdiskmanager -k your_vm_name.vmdk

and wait until it finishes - ensure the host has sufficient working free space for your particular disk and VMware configuration; do not rely on an exact one-to-one requirement.

Results

	VM size
Original vmdk size	70GB
After zeroing free space and clean-up	40GB

Credits:

Hierarchy of perceptions

2025-07-05T21:20:05Z

I was thinking of the old conundrum of how we perceive the objective world or reality - it’s always through our limited sensory organs. Then it has to be processed: some small latency in the brain, maybe some evolutionary heuristics, our genetic background, etc. after all this we get a tainted fragment of the world.

We know these facts: we aren’t getting a full picture, i.e., our perception is limited. We can have levels of perception which depend on various factors, some of which are internal (currently researched and refined in the fields of psychology & neuroscience) and others external. As a species, we have cultivated them, I’d reckon, starting with the first human tribes.

Society is both a necessity and a natural extension of the late humans. The interesting detail is society's effects on our perceptions of reality. I keep using perception at plural because I’m making the case there’s a multiplicity of them (maybe I’m channelling Deleuze here). What I want to add on top of the plurality of perception is its hierarchical property in relation to the immovable real world.

Why do I believe we can switch our perception of the world? It is self-evident, but this property forces it to move under our radars. We box ourselves into a certain instance of reality through a specific perception.

Let’s say, age-wise, we are in our thirties and our career takes center stage - this becomes the instance of how we perceive the world. Thus, our prima perception is bound to this context and the other instances take a second place. Other instances? we can think of items that ooze meaning in our lives, e.g. our loved ones, passions, hobbies, etc.

This creates a hierarchy of perceptions which, if we’re not aware of it, we can designate as the most important the “wrong” instance of reality. These hierarchies are subjective, but to what degree? What if we get stuck in a perception bubble and we forget or ignore our health? - in the future we might experience the perception of being ill to a higher degree and, sadly, get stuck in it longer or for the rest of our life.

We can sketch this out at a macro and micro-level. The hierarchy of perceptions guides our choices to a certain extent in different periods of our lives (macro). But at any point there’s a multiplicity of perceptions of the same position of reality which unified unto infinity would give us a full picture.

Harmonizing Projects: Navigating the Graph of Estimation and Detail

2025-07-05T21:20:05Z

As someone who finds solace in the rich nuances of sound, I often draw parallels to the world of development. Ponder this: Just as the quality of music affects the depths of my appreciation, the broad overview of a project offers a satisfying clarity. Yet, the devil, as they say, is in the details.

In much the same way I lose myself in the symphonies of sound, developers often journey through the intricate web of a project, visualized as a vast graph. At the heart of this graph lies the core objective or goal, the resonating note that sets the tone. As we journey outwards, moving towards the peripheries, the graph branches out, much like the intricate harmonies and melodies in a musical piece.

And then, there are the leaf nodes, the finer details. Just as the subtlest notes in music might escape the casual listener, these granular elements of a project often elude our initial estimations. The further we delve into these leaves, the more we're confronted with the unexpected — the unforeseen challenges, the complexities that weren't apparent from a distance. It's akin to the ambient noise that permeates through my open-back headphones, often distracting and always unpredictable.

In the past months, I've found myself gravitating towards noise-cancelling headphones, a testament to the need for focused immersion. Similarly, as developers, our approach to project estimation needs the metaphorical equivalent of noise cancellation. Recognizing the uncertainties that lurk in the granular tasks, adjusting our approach, and continuously recalibrating our strategies becomes paramount. After all, in both music and development, it's about harmonizing the broad strokes with the intricate details, creating a masterpiece that resonates with purpose.

Don’t stress, use the right gear for the job

2025-07-05T21:20:05Z

Whilst I consider myself an audiophile, I also like to think I’m a pragmatist i.e. best of both worlds: don’t go over the top with snake oil gear but at the same time recognise that sound quality plays a pivotal role in how I listen and enjoy music.

As developers, we use various ways to relax, in my case music plays a vital role - it decouples me from the “now”, triggers the creation of happy chems in the brain and finally re-syncs my contorted perception towards “beauty can exist in the world whatever the circumstances might be”.

In the last couple of months, a new requirement has arisen: noise cancelling headphones, as the surrounding noise was having a negative effect on my productivity. I mostly use open back headphones, actually all of them are open back so they let outside noise easily in.

I addressed the finding of the perfect pair of noise cancelling headphones by also factoring in their sound quality. After some weeks a candidate emerged: Sony WH-1000XM4, the fourth iteration of their NC cans - the reviews and online consensus revealed top-notch NC and more than OK sound quality.

To digress a bit, my reference cans are the old timers from Sennheiser: the venerable HD600s released in 1997 with their odd coating. People affectionately call them “kitchen”-cans. Luckily, I got the original looking ones from ‘97. The updated design looks in-sync with the modern times. Before them I tried other headphones: I went from Grados (SR225e) to Audeze (LCD-2f), which I still own but rarely use, also listened to a myriad of other models.

For me, the 600s’ timbre, especially in the vocals department, doesn’t have any competition. They’re just magic if you will, just like the classic BBC monitors, nowadays best incarnated as the Harbeth P3ESR - they’re not perfect speakers by any means, but their timbre and reproduction of vocals are just magic.

Back to the Sonys - bought them, the NC feature worked like a charm but I had a major disappointment in the sound quality department - out of the box they come tuned with a huge bass bump which bleeds into the mids and makes everything sound… well, muddy.

I spent again a week researching different EQ settings, various fixes to make them sound better. Finally, I used SoundSource coupled with Apple’s default AUNBandEQ (parametric EQ) to apply fixes I’ve found online . The results - quite impressive, the sound was much better, but it wasn’t perfect, most likely because there are many factors that influence each individual frequency perception like the shape of the ear, the length of the ear canal, the inherent subjectivity of the brain, etc.

This was a failed experiment. I truly believe you can EQ your headphones to fit your ears; the issue is the amount of energy you have to put into this and there’s always seemed to be that one track where a cymbal just sounds off or too edgy.

Therefore, I caved. I just set the “Vocal” profile in their DSP, which doesn’t sound horrible, and went on with my business, ignoring the issue for some time but still having a feeling that they aren’t good enough somehow.

Then it dawned on me: I got them for a specific role - noise cancellation i.e. not to trick my brain that I’m listening to magic. When thinking in that specific structure, the dissatisfaction went away, because when I wanted magic, I could always switch to my 600s coupled with the Chord Mojo or the Burson Soloist brute and a tube buffer , all mixed with a quiet night: just sit back and enjoy the music.

As in programming and many other fields: use the right gear for the job and appreciate things for what they excel at.

blog of Marian Posăceanu - rubyist most of the time

PRs are dead, long live PRs?

The half-life of a programmer

Tangents

Relation to age

The half-life of a programmer

Referential humility

Conclusion

Using Firebug as a scalpel, yet not for web development

References

Tomorrow is the first day of How to web 2010, this should be fun

Reference

The inherent entropy in our lives: to resist or to...

References

The frontend backend debacle

Shedding some light into UUID version 4 in Ruby and Rails

In Ruby's stdlib, the UUID method is found in SecureRandom:

The Rails version uses the uuid-ossp PostgreSQL extension:

Ruby standard library implementation

uuid-ossp extension implementation

Conclusions

References

Ruby 2.2.0 Preview 1 quick Rails benchmarks

Ruby 2.1.2p95

Ruby 2.2.0preview1

Issues

Conclusion

Programatica 2010 after thoughts

On zygohistomorphic prepromorphisms

Recursion, but with memory

Adding just one more layer

Why anyone would do this

The cost of names

A small observation

References and provenance

On writing artisanal code

On unnamed abstracts, entities and happiness

References

On semantic Ruby block constructs

The semantic rule

Lambdas

Conclusion

References

On Ruby modules and concerns

Roles and modules

ActiveSupport::Concern

Uses and trade-offs

Further reading

On Ruby 2.0 memory usage, Unicorn and Heroku

The old days of Ruby 1.8.7 and REE

The recent release of Ruby 2.0

What about Heroku ?

Wrap-up

Related articles

On font rendering consistency across browsers

Update № 1

Update № 2

References and 2026 context

Is Rubinius 2.2.3 production ready ?

The setup

On to the benchmarks!

ApacheBench config

unicorn.rb

puma.rb on Rubinius 2.2.3

puma.rb on JRuby 1.7.9

Conclusion

Update

Installing a rails mysql stack on my laptop was a bit tricky

References

Improve Rails performance by adding a few gems

Benchmarking methodology

The escape_utils gem

The fast_blank gem

The oj gem

Using jemalloc

Dig into your Rails app

Conclusion

How to Web conference, random thoughts, mostly live - five years later

References

How to Web Conference, random thoughts, mostly live

In Ruby's stdlib, the UUID method is found in `SecureRandom`:

The Rails version uses the `uuid-ossp` PostgreSQL extension: