Luca Guidi

Why Your `app version` Golang CLI Command Loads Your Database Client (And How to Fix It)

Thu, 23 Oct 2025 00:00:00 +0000

You type myapp version to check the version number. But behind the scenes, your application loads the database client, git service, API handlers, and file system watchers. All that code initialization for a command that just prints a version string.

This is the hidden cost of traditional dependency injection in Golang CLI applications. Every command pays the startup cost of all commands. This post shows how I solved this problem with a simple two-phase initialization pattern that achieves true lazy loading while keeping tests clean.

Setup Hanami with Sidekiq

Mon, 20 Feb 2023 00:00:00 +0000

Introduction

Sidekiq is the standard in the Ruby ecosystem for background jobs. This short tutorial will show you how to set up Sidekiq in a Hanami application using Docker Compose.

For the basic setup, please look at my previous tutorial: Getting Started with Hanami and Docker Compose. We’ll modify that demo application to support Sidekiq.

Steps

1. Add the Sidekiq gem

⚡ bundle add sidekiq

2. Add a Sidekiq provider

Add a Hanami provider for Sidekiq (config/providers/sidekiq.rb).

Getting Started with Hanami and Docker Compose

Mon, 13 Feb 2023 00:00:00 +0000

Introduction

Hanami 2.0 is the perfect Ruby framework for building robust and fast API applications. The 2.0 version comes without a persistency layer (that will be a 2.2 feature).

Today we’ll learn how to set up a Hanami app with a secure Redis instance using Docker Compose in a few steps.

As a prerequisite, you’ll need Docker, cURL, Ruby 3.2+, and Hanami 2.0+.

Steps

1. Generate the app

Generate a new Hanami 2.0 app.

Getting Started with Hanami and GraphQL

Mon, 06 Feb 2023 00:00:00 +0000

Introduction

Hanami 2.0 is a productive Ruby framework that quickly supports you in building API applications.

Today we will see how to get started with Hanami and GraphQL in ten steps.

We will create the app and a simple code to support the GraphQL schema with a simple Query, including a request spec. The theme is a classic Star Wars schema.

As a prerequisite, you’ll need Ruby 3.2 and Hanami 2.0.3.

2022: A Year of Growth and Accomplishments

Fri, 23 Dec 2022 00:00:00 +0000

It’s been a busy and rewarding year, both personally and professionally.

I turned 40 in June! That was an opportunity to think about time passing. I’m committed to spending time doing the things I always wanted to do but never took the courage to do.

For example, I started taking swimming lessons. 🏊 For a person that was terrified by deep water, it’s a vast improvement. 💪

Another exciting news was to start playing live electronic music. 🎧 It happened a few times, and that was fun! A lot of fun! 😎

Striking a Balance: Why Prioritizing Both People and Processes is Key to Success in Agile Teams

Tue, 13 Dec 2022 00:00:00 +0000

As a software architect who has worked in Agile environments for several years, I have seen the benefits of the Agile Manifesto’s emphasis on “people over processes.”

However, there is also value in challenging this principle and considering the potential drawbacks of prioritizing people over processes in certain situations.

One of the main arguments for prioritizing people over processes is that it allows for more flexibility and adaptability in the development cycle. By focusing on team members’ talents and skills, Agile teams can respond quickly to changes and challenges as they arise. This approach can be especially beneficial in fast-paced industries where the market and technology constantly evolve.

Open Source Updates: Q1 2021

Mon, 12 Apr 2021 00:00:00 +0000

Hanami CI stability

I was one of the early adopters of Travis CI, but in more than a decade the service that served so well the Open Source community is not the first class solution that it used to be.

We decided to migrate to GitHub Actions, so I spent time to migrate all the Hanami gems to GitHub Actions. Not all the Open Source work is for the game of the fame.

Open Source Updates: December 2020

Mon, 11 Jan 2021 00:00:00 +0000

Brief 2020 recap

During 2020 due to the pandemic and new job role (software backend architect at Toptal) I had less time to dedicate to Open Source. Luckily enough, other amazing people took care of projects that I care about.

Two people above all: Tim Riley for Hanami 2 and Tom Scott for redis-store.

Let’s start with the easy one: I don’t actively maintain redis-store anymore, Tom is the main person behind it, but I’m immensely grateful that he’s devoted to the project, which after 12 years is very mature.

Ruby Method Overloading

Wed, 22 Jul 2020 00:00:00 +0000

Method Overloading is a programming language feature that allows you to define multiple signatures (and implementations) of the same method.

Ruby doesn’t have such a feature. It was a shocking discovery when I switched from Java.. a very long time ago.

We can somehow trick the language using optional and keyword arguments.

But how can we have real isolated implementations of the same method? I wrote a hack to make this possible based on method arity.

Hanami::API on Amazon AWS Lambda

Wed, 04 Mar 2020 00:00:00 +0000

The Hanami team & I, recently announced Hanami::API: a minimal, extremely fast, lightweight Ruby framework for HTTP APIs.

Its minimalism, the small memory footprint and its performance, make Hanami::API a good candidate to build microservices.

Today, we’re gonna deploy a small service on Amazon AWS Lambda. It’s an Amazon AWS product that allows to deploy an autoscaling HTTP service. You are charged for every 100ms your code executes and the number of times your code is triggered. Having a fast framework like Hanami::API helps to reduce the costs of running a service on AWS Lambda.

Introducing hanami-cli

Tue, 10 Oct 2017 00:00:00 +0000

Introducing hanami-cli: a general purpose Command Line Interface (CLI) for Ruby. Learn why Hanami replaced thor in favor of hanami-cli and how to use it to build a CLI application in 5 minutes.

Why not `thor`?

For long time we used thor 🔨 to build the Command Line Interface (CLI) of Hanami. But as the time passed, we needed more control on the internals of our implementation.

The Hanami 🌸 command line needs two crucial features: subcommands and extendibility.

How To Test Ruby CLI: Console

Wed, 08 Feb 2017 00:00:00 +0000

One of the most interesting challenges I met during Hanami development is to write isolated integration tests. The framework ships with an extensive Command Line Interface (CLI) to generate (or destroy) code, start the server, open a Ruby (or a database) console, create/drop the database, run the migrations, precompile assets, and print informations.

Console

Hanami console is an interactive REPL based on IRB, which is useful to interact with the objects defined in a project.

How To Test Ruby CLI: Code Generators

Wed, 01 Feb 2017 00:00:00 +0000

Code Generators

Code generators is a helpful feature that allows to generate code files. The main purpose is to speedup the development process. Hanami has code generators for projects, apps, actions, models, and migrations. Here’s an example:

How To Test Ruby CLI: The Setup

Fri, 20 Jan 2017 00:00:00 +0000

Full Isolation

As I want to have integration tests to use CLI commands for real, the test suite is free of mocks/stubs. When I ran it, only real commands are executed against the shell.

Lessons Learned In Open Source: The Motivations

Tue, 17 Jan 2017 00:00:00 +0000

It was a rainy Wednesday. That 5th of Oct 2011, I was driving to work, stuck in the traffic, while the radio announced it: Steve Jobs was died.

I was shocked. For me and more than one generation, he was the iconic leader, whom fame and success went beyond his tech career.

“Can I achieve the same?” I thought.

Since that day, we self-proclaimed visionaries, we tried to emulate his attitude. For some of us it’s the stupid game of being mean with employees, for others, it’s to found startups to try to “disrupt” tech industry with the “next big thing™”.

Isolate Global State

Tue, 27 Dec 2016 00:00:00 +0000

Using global state in software programs, is handy for development, but evil to maintain.

It can easily become source of bugs that are triggered by edge cases which are hard to track down.

Let’s see why, and how we can mitigate the problem.

An Example Of The Problem

For instance, in Hanami code base we need to test how the framework configures itself according to certain env variables.

We used to test like this:

The Penguin That Can't Fly

Tue, 07 Jun 2016 00:00:00 +0000

A short story about OOP, interfaces and soft typing

Today is the day at the headquarters of Spectacular Foo Ltd. The rising firm of the indie gaming scene is going to release its next blockbuster title: Banal Birds.

The year is 2019, Ruby 3 is three times faster and has soft typing, what a crazy coincidence that solves everything! It was a nostalgic decision but, you, as the lead developer decided to use Ruby for this project.

25,000+ Req/s for Rack JSON API with MRuby

Wed, 09 Dec 2015 00:00:00 +0000

Last month I gave the closing keynote at RubyDay 2015 by talking about Lotus and the future of Ruby.

For the attendees, the most surprising part of my speech was about MRuby. It’s a minimal version of Ruby, that can be embedded in any system that supports C.

I think that this technology can play a key role for Ruby in the next years. The simplicity of the language can be used within complex systems.

JSON API Apps With Lotus

Tue, 24 Nov 2015 00:00:00 +0000

Do you need a fast and lightweight JSON API app? It must be powerful, flexible, quick to develop and easy to deploy?

There is a simple solution for all these requirements: to use Lotus gems to build it.

Lotus is well known for full stack web applications (via lotusrb), but all the gems of this toolkit can be used as standalone components in existing Ruby applications.

It this case we will compose together the router and the actions to create a JSON API app that returns informations for books.

Effective TDD With Ruby: Tmux Setup

Tue, 17 Nov 2015 00:00:00 +0000

Do you find Test Driven Development (TDD) good in theory but hard to practice? Do you think it requires too much discipline and you don’t have time? Or, are you just struggling to get your workflow streamlined? Fighting to glue your tools together?

Well, you can improve a lot, by borrowing some tricks from me. I’ve practiced TDD with Ruby for many years now, and built an entire web framework only with these techniques.

Effective TDD With Ruby: Vim Setup

Tue, 27 Oct 2015 00:00:00 +0000

Well, you can improve a lot, by borrowing some tricks from me. I’ve practiced TDD with Ruby for many years now, and built an entire web framework only with these techniques.

Effective TDD With Ruby: Time & Flow

Tue, 20 Oct 2015 00:00:00 +0000

Well, you can improve a lot, by borrowing some tricks from me. I’ve practiced TDD with Ruby for many years now, and built an entire web framework only with these techniques.

Effective Remote Working

Tue, 13 Oct 2015 00:00:00 +0000

Going remote is an appealing lifestyle, but without a guidance we can easily get lost. What’s the right balance between professional and personal life? How to make sure that you’ll finish your tasks by the end of the day?

You can get it right without too much effort. It’s just a matter of forming the right habits.

I work as a remote software engineer for three years now. During this time, I was successfully employed at Litmus first and then at Codeship. Now I’m a independent consultant (hire me) and Open Source developer. All remote, while having a family and an office in our living room. Here’s what I’ve got to share.

Lotus And Microservices

Tue, 05 May 2015 00:00:00 +0000

The monolith is good (at the beginning)

The easiest and convenient way to build a complex system is to use message passing. When all the components live in the same process, engineer’s life is easier.

Development cycles are shorter, interfaces can change quickly. When deploy time arrives, we will have only one deliverable to push. This is just great.

{% twitter There is an analogy between “message passing” and in person communication. %}

A New Roadmap For Lotus

Thu, 01 Jan 2015 00:00:00 +0000

Last year was great, and 2015 brings new challenges to Lotus.

Learn from mistakes

When I released the first version back in June it was a wild, unexpected success. There was an uncommon hype for the initial version of a “yet another web framework for Ruby”.

Probably, Lotus’ vision met the needs of a lot of developers in our Community. The demand of a rich, stable ecosystem of libraries and patterns to build applications that are dead simple to build and maintain.

2014 Retrospective: A Year Of Lotus

Tue, 23 Dec 2014 00:00:00 +0000

This has been a great year for Lotus.

At the beginning of 2014 I decided to open source this less invasive and simple framework for Rack.

Back in the day, it was just a software stored in my hard drive. An experiment that turned to be a fresh take for web development with Ruby. It had in it the seminal work of what is Lotus today, but it required patience for its blossoming.

Introducing Lotus::Validations

Thu, 23 Oct 2014 00:00:00 +0000

Data validation is an important piece in software architecture. It guarantees that the successive layers will operate on correct input. In the existing Ruby frameworks we’re used to see this responsibility flatten down into models.

The problem with this approach is that we end to mix a lot of validations for different use cases in a single place. When the application grows in complexity, we add new validations. If often happens that some rules are incompatible with others, then we introduce nasty conditionals to trigger only a subset of them.

Meaningful Exceptions

Mon, 22 Sep 2014 00:00:00 +0000

Writing detailed API documentation helps to improve software design.

We already know that explaining a concept to someone leads us to a better grasp. This is true for our code too. This translation process to a natural language forces us to think about a method from the outside perspective. We describe the intent, the input, the output and how it reacts under unexpected conditions. Put it in black and white and you will find something to refine.

Introducing Lotus

Mon, 23 Jun 2014 00:00:00 +0000

A year and a half ago I felt frustrated by the state of the art of web development with Ruby. Secretly, in my spare time, I started hacking with new ideas, taking nothing for granted, destroying and starting from scratch several times, until the software was distilled in a beautiful API.

It took me a decade to get here, by following a process of subtraction of what isn’t essential. Countless refinements to achieve modularity, to balance elegance with performance, and convenience with solid design.

Three Things To Know About Composition

Mon, 09 Jun 2014 00:00:00 +0000

A few days ago Aaron Patterson wrote a in interesting article about composition vs inheritance with Ruby.

He says that when inheriting our classes directly from Ruby’s core objects such as Array, our public API for that object will become too large and difficult to maintain.

Consider a powerful object like String which has 164 public methods, once our library will be released, we should maintain all that amount of code. It doesn’t worth the trouble, probably because we just wanted to pick a few methods from it. It’s better to compose an object that hides all that complexity derived from String, and to expose only the wanted behaviors.

Rails Is Not Dead

Mon, 19 May 2014 00:00:00 +0000

A few years ago, my lead develop of the time, told me: “Beware of the coupling that you’re introducing in your models”. My answer was: “Hey, you don’t know what you’re talking about, this is ActiveRecord”.

I was an unexperienced developer fascinated by the innovation that Rails introduced. After all, my technology was able to get rid of all that configurations, and all that boring stuff from the past.

- Patterns?
- I don't need them. I have the Holy Grail: MVC.
- Interfaces?
- Are you kidding me? This isn't Java, it's Ruby!

We all have been there. We were recovering from the consequences of the New Economy economy bubble burst. A new wave of technologies was raising: AJAX, Rails, and the Web 2.0. All was exciting, we felt like we’d learned from the past mistakes. We were creating a new way to sell software, we needed to be agile, fast and pragmatic.

We Are All Wrong About Software Design

Mon, 28 Apr 2014 00:00:00 +0000

We are all wrong. When it comes to talk about opinions this is the way that things work. Everyone has her or his own beliefs shaped by years of experience in the field, frustrating code, books, successes, etc. How can all these backgrounds fall into a one unified theory? They just can’t.

You’ve always been told to pick the right tool for the job. But what’s the right tool? You decide it, according to your practical knowledge.

Introducing Lotus::Model

Wed, 23 Apr 2014 00:00:00 +0000

Almost all the Ruby frameworks for the Model layer mix up business logic with database details. This kind of architecture leads to god classes, slow build times and to a general bad design. These problems are well known to legacy projects’s maintainers.

What if we assign these roles to smaller components that are able to collaborate together? Imagine how life changing would be to work just with objects, without worrying how to persist them. How easy and fast would be testing them? How small and well defined would be your objects?

Thread Safety With Ruby

Thu, 27 Mar 2014 00:00:00 +0000

Moore’s law is over. Modern computation is exploited by running processes on multiple cores. Ruby has always ignored this trend, and the community didn’t put enough attention on this topic.

Ruby’s model for concurrency is based on threads. It was typical approach for object oriented languages, designed in the 90s. A thread is sequence of instructions that can be scheduled and executed in the context of a process. Several threads can be running at the same time.

Introducing Lotus::View

Sun, 23 Mar 2014 00:00:00 +0000

The missing part of all the Ruby web frameworks is the distinction between views and templates. A view is an object that encapsulates the presentation logic of a page. A template is a file that defines the semantic and visual elements of a page. In order to show a result to an user, a template must be rendered by a view.

Keeping things separated, helps to declutter templates and models from presentation logic. Also, since views are objects they are easily testable. If you ever used Mustache, you are already aware of the advantages.

Redis Scripting with MRuby

Wed, 26 Feb 2014 00:00:00 +0000

MRuby is a lightweight Ruby. It was created by Matz with the purpose of having an embeddable version of the language. Even if it just reached the version 1.0, the hype around MRuby wasn’t high. However, there are already projects that are targeting Nginx, Go, iOS, V8, and even Arduino.

The direct competitor in this huge market is Lua: a lightweight scripting language. Since the version 2.6.0 Redis introduced scripting capabilities with Lua.

# redis-cli
> eval "return 5" 0
(integer) 5

Today is the 5th Redis birthday, and I’d like celebrate this event by embedding my favorite language.

Introducing Lotus::Controller

Sun, 23 Feb 2014 00:00:00 +0000

Lotus development is going well. The experiment of open source a framework per month is sustainable. I have the time to cleanup the code, write a good documentation and deliver great solutions.

This month, I’m proud to announce Lotus::Controller.

It’s a small but powerful and fast framework. It works standalone or with Lotus::Router and it implements the Rack protocol.

Actions

The core of Lotus::Controller are the actions. An action is an HTTP endpoint. This is the biggest difference with other frameworks where they use huge classes as controllers. Think of Rails, where a single controller is responsible of many actions and holds too much informations. Lotus is simple: one class per action.

Building Sinatra with Lotus

Tue, 28 Jan 2014 00:00:00 +0000

The beauty of Lotus is the composition of its frameworks. Each of them is well designed to achieve one and only one goal. The main advantage of this architecture is that delevopers can easily use and reuse those frameworks in countless ways.

Lotus::Router accepts anonymous functions as endpoints. This feature can be used to build Sinatra with it.

Initial setup

We need to setup a Gemfile with:

source 'https://rubygems.org'
gem 'lotus-router'

As second step, we create an Hello World application with Lotus::Router (run with rackup application.rb):

Introducing Lotus::Router

Thu, 23 Jan 2014 00:00:00 +0000

For me, the first step in the long path of building a web framework was an HTTP router. By understanding requests coming from an user, it pays back with an immediate gratification: start it, open a browser and see a result.

My hope was to embark on a short journey, and reuse as much as possible existing libraries. But I soon discovered that the biggest problem of Ruby web frameworks is reusability of components. Rails uses journey, which is coupled with ActionPack code base. Sinatra has its own hardcoded routing system. Plain Rack apps require the developer to fiddle with low level details of env.

Announcing Lotus

Wed, 01 Jan 2014 00:00:00 +0000

I’m pleased to announce Lotus: the Open Source project I’ve conceived, hacked and built during the last year.

Lotus is a full stack web framework for Ruby, built with lightness, performances and testability in mind. It aims to bring back Object Oriented Programming to web development, leveraging on stable APIs, a minimal DSL, and plain objects.

Standalone frameworks

It’s composed by standalone frameworks (controllers, views, etc..), each one is shipped as an independent gem, in order to remark the separation of concerns. They can be used with any Rack compatible application for a specific need: for instance, Lotus::Router can be used to dispatch HTTP requests for a pool of Sinatra applications.

On Happiness

Tue, 17 Dec 2013 00:00:00 +0000

As a naive younger man, I have always been disappointed by how many year resolutions have missed in the past. Mostly because they are a failure by design: the wishful self is delighted to dictate the new agenda of change, where all the lazyness, tiredness, and unforeseen accidents will magically disappear to leave room to a bright, joyful and productive future. This will never happen.

What really works is to plan nothing

If you aim to write more, just find the time and do it. Don’t plan, do it. Todo lists were invented to sit and watch us with disapproval, they always generate a sensation of unfulfillment, we are always inadequate and behind the goal. And if we’re still struggling, we probably have chosen the wrong desire. Better admit the failure, turn it down, than blindly follow somebody else’s dream.

Introducing Redis Store

Mon, 18 Jun 2012 00:00:00 +0000

[ I wrote this post for Redis ToGo, you can find the original article here and the related discussion on Hacker News. ]

Redis Store aims to be a toolkit for your Ruby applications, it natively supports sharding, master/slave replication, marshalling, timeouts and namespaces. Plus, it’s really easy to use with the most popular frameworks, such as Ruby on Rails.

If you love modularity, you will love Redis Store too: under the hood it just activates, at runtime, the best set of low level features requested by the above software layers. It’s delivered as a set of gems, one for each targeted framework, with a common background that’s the redis-store gem itself. This decision helped me a lot to deal with different versions of Ruby, several frameworks, and versions.

Lean Rails App Setup

Mon, 27 Feb 2012 00:00:00 +0000

I’m currently working as a consultant for an UN agency (IFAD) and we have a portfolio of ~15 Rails apps, developed in the last four years. The environment is heterogeneous and an half dozen of these projects are interfacing with legacy software and they are legacy themselves. As counterpart, the new apps we are developing are running on the latest bleeding edge technologies (Ruby 1.9.3, Rails 3.2, MongoDB, Redis, WebSockets etc..).

HTML5 Geolocation Testing with Cucumber

Sun, 13 Feb 2011 00:00:00 +0000

[ I wrote this post for frestyl, you can find the original article here. ]

Here at frestyl we're working hard, using cutting edge technologies to promote their wider-scale adoption and to help set the new standards with our direct experience. In the past months our geolocation service has been changed from a somewhat flaky IP lookup to the new HTML5 W3C draft. Our users noticed the difference and they are happier of the new level of precision.

Why Customer Service Matters

Sun, 30 Jan 2011 00:00:00 +0000

A few months ago I bought a flash music player for my music blog.

Surprisingly, it doesn’t support .m4a files. I noticed that lack, once I payed for it. Just for curiosity (and to know if I was missing something in the documentation), I filed an issue in their support forum (as of the 30rd of June), asking if their player can reproduce other formats rather than the aforementioned one. I still didn’t got a reply from the software firm. I solved the issue by myself, converting all the music in mp3 and it’s no longer a problem to me. They just could have replied with a “yes” or a “no” and I would be happy just to be aware, but they didn’t. Aside to this issue, I asked for other technical questions and still no words from them.

How to install ruby-debug on Ruby 1.9

Fri, 04 Sep 2009 00:00:00 +0000

One of the major problem which prevent the migration to Ruby 1.9 is the lack of the porting of ruby-debug.

Here the steps I followed to made it working on my MacBook with Multiruby:

sudo gem install rake-compiler ruby_core_source --no-rdoc --no-ri sudo gem install ruby-debug19 --no-rdoc --no-ri

I hope it works for you too!

Rails: Unobtrusive and i18n Javascript confirm

Wed, 17 Jun 2009 00:00:00 +0000

How many times do you heard you should separate content from behavior? Never? Hmmm don’t try to cheat me.. So, why do you still use :confirm option for link_to helper?

Here a little snippet to archive our goal, and as extra bonus, you get it i18n:

<script type="text/javascript"> window._authenticity_token = ""; </script>

t(:’asset.destroy’),
:class => “delete”,
:’data-confirm’ => t(:’asset.destroy_confirm’) %>

$(document).ready(function(){ $(".delete").bind("click", function() { if(window.confirm($(this).attr("data-confirm"))) { $.ajax({ url: $(element).attr("href"), data: { _method: "delete", authenticity_token: window._authenticity_token }, type: 'post', dataType: 'script' }); } return false; }); });

Memoria: Statistics for Redis

Sat, 13 Jun 2009 00:00:00 +0000

A couple of days ago I setup this blog with Redis as cache container, thanks to my Ruby gem: redis-store.

Now, following the old itch-your-own-scratches rule, I created a little Sinatra web application for Redis statistics: Memoria.

# Getting Started
(sudo) gem install sinatra dm-core do_sqlite3 rspec (sudo) gem install ezmobius-redis-rb jodosha-memoria -s http://gems.github.com memoria /path/to/installation cd /path/to/installation cp memoria.yml.example memoria.yml rackup config.ru --port 9292 mongrel

Memoria is still in an embryonic stage, feel free to suggest features.

Hanoi: Automated jQuery tests with QUnit

Tue, 09 Jun 2009 00:00:00 +0000

About a month ago, we have released adva-cms 0.2.0, the most relevant change was the migration from Prototype to jQuery. I always been a loyal Prototype fan, and, until then, I always tested my code with `unittest.js`, combined with `jstest.rb`.

Like other rewrite we needed to rely on a solid test layer, but what I noticed was the lack of a valid automation support for QUnit, the test framework used internally by the jQuery team. So, in a couple of days I built what we need, just creating a custom version of jstest.rb and changing a little bit QUnit, in order to communicate with it.

Click To Globalize for Rails 2.3

Fri, 10 Apr 2009 00:00:00 +0000

For all of you who don’t know what I’m talking about, **Click to Globalize** is a Rails plugin for in-place translations. Now it’s compatible with Rails 2.3 and It’s also the most clean and polish version of ever, let me explain what’s changed.

Engine

Yes, **Click to Globalize** is now an [engine](http://rails-engines.org/), this means all the controllers, the helpers, the routes and the other stuff, now lives in `vendor/plugins`. No more clutter with flying files, except for one javascript and one stylesheet.

I18n

The [i18n team](http://i18n-rails.org/) (myself included) worked hard to build a **consistent API** for i18n. Starting from Rails 2.2 we have bundled a gem for this purpose, and now my plugin is totally compliant with this system, this **agnosticism** allow you to use whatever i18n backend you want. Click to Globalize is **no longer a Globalize extension!!**

RESTful

The plugin now bundles two **full RESTful** controllers: `TranslationsController` and `LocalesController`, respectively `/translations` and `/locales`.

Lightweight

I replaced the annoying `around_filter` system, with a more lightweight one, based on the observation of `ActionView#render`.

Formatting

I removed the support for **Markdown** and **Textile**, personally I never used so much, and don’t think they are so related with i18n.

Deprecations

The old `globalize?` method is deprecated in favor of `in_place_translations?`.

You can find all the new instructions to the [project page](http://lucaguidi.com/projects/click-to-globalize) or on [GitHub](http://github.com/jodosha/click-to-globalize).
Enjoy!

Boost Rails Sessions

Tue, 31 Mar 2009 00:00:00 +0000

There are many dark corners and hidden features in a big framework like **Rails**.

Digging inside the code of **ActiveRecord** I discovered an interesting class: **SqlBypass**. When you set your session store on ActiveRecord it will use a **Base** subclass for deal with database store. This configuration adds an useless overhead for your application, because each session read/write will go through the complex callbacks system of ActiveRecord.

For these reason is highly advisable to use **SqlBypass**. As the name suggest it bypasses all the callbacks and simply performs read/write operations.

Rake tasks for run Rails engines migrations

Tue, 24 Feb 2009 00:00:00 +0000

I created a patch for run engine’s migrations

I created a patch for run engine’s migrations, it adds two Rake tasks:

db:migrate:engines
db:migrate:engines:down

The first one allows to run all the migrations stored in the db/migrate directory of each plugin. It runs migrations in the same order Rails::Initializer register the plugins, this means if you force an order by environment.rb, it will be reflected on migrations order.

Example: You have four plugins in your app: apple, bar, foo, pear.



How to use Sprockets with Rails
Mon, 23 Feb 2009 00:00:00 +0000
Sam Stephenson has recently released a Javascript preprocessor called Sprockets.
It’s distributed as Ruby gem, and it helps to declare scripts dependencies through special comments, and safely build them one script. It’s very useful for maintain your Javascript projects, extract reusable code and share across applications.
Installation

  
$ (sudo) gem install sprockets
  
  It will also install sprocketize executable.

How it works?

  To declare a dependency use require directive:

//= require 
//= require "cookies"
  
  When you use angular brackets the script will be searched in all the Sprockets load path, if you use quotes instead, you are forcing to load the file from the current directory. Usually you should use the first way to require frameworks or libraries and the second one for your scripts.



Getting started with Cached Models
Tue, 17 Feb 2009 00:00:00 +0000

Getting started with CachedModels from Luca Guidi on Vimeo.


Rails caching and Javascript pt. 2
Fri, 13 Feb 2009 00:00:00 +0000
In the previous article I showed how to take the advantage of Javascript for page caching.
This cache strategy allows to generate static HTML and allow the web server to serve it, without waste a useless Rails request/response cycle. But, since the cached page is stateless we ask help to Javascript for make it a little bit dynamic.
Flash

  All of you has probably noticed that flash object is an enemy of page caching. Let me show you why.

class SessionController 
  Now suppose the application is in a blank state, when the user hits the dashboard_url, ActionPack will cache the page, including the flash status. This means it will be always rendered, even if the flash will be expired.



Rails caching and Javascript pt. 1
Mon, 09 Feb 2009 00:00:00 +0000
Rails offer a multi-level view caching based on: page, action and fragment.
Page Caching

  For Rails cache a page means to generate the HTML code on the first visit, then allow front-end web server to send it statically.

  This is the fastest way to serve pages, because Rails puts the cached page in the public folder, the web server intercept the request and doesn’t forward it to the application server, avoiding an useless Rails request cycle.

class HomeController 



Hash deep search
Wed, 04 Feb 2009 00:00:00 +0000
I’m back and I wanna share those simple snippets with you:~


class Hash
  def deep_has_key?(key)
    self.has_key?(key) || any? {|k, v| v.deep_has_key?(key) if v.is_a? Hash}
  end
  alias :deep_include? :deep_has_key?
  alias :deep_key? :deep_has_key?
  alias :deep_member? :deep_has_key?
def deep_has_value?(value)
self.has_value?(value) || any? {|k,v| v.deep_has_value?(value) if v.is_a? Hash}
end
alias :deep_value? :deep_has_value?
end



Example:

{:a => {:c => 'c'}, :b =>{:d => {:e => 'e'}}}.deep_has_key?(:e) # => true
{:a => {:c => 'c'}, :b =>{:d => {:e => 'e'}}}.deep_has_key?(:z) # => false
{:a => {:c => ‘c’}, :b =>{:d => {:e => ’e’}}}.deep_has_value?(’e’) # => true
{:a => {:c => ‘c’}, :b =>{:d => {:e => ’e’}}}.deep_has_value?(‘z’) # => false



Skip Mocha
Thu, 23 Oct 2008 00:00:00 +0000
Yesterday I confessed how messed up was CachedModels 0.0.2. The problem was pretty simple: I made some mistakes mocking up Memcached behaviors.
The Dilemma

  I massively use Mocha for track how many calls CachedModels performs against the cache, and (ideally) for run test suite without any server active.
  But, this approach led me to broken results. Should I keep out Mocha from my tests?

The Solution

  Why don’t mock the mock? We know, Ruby allows to add behaviors to classes at runtime, Mocha itself take this advantage.
  I added to my test_helper.rb the following code:

if ENV['SKIP_MOCHA'] == 'true'
  class Object
    def expects(*args)
      self
    end
def method_missing(method_name, *args, &amp;block)
end

end


Cached Models 0.0.3
Wed, 22 Oct 2008 00:00:00 +0000
Since I began to work as professional developer I learned a lot of stuff, but, first of all I learned to be honest with customers and with the Community.
I have to admit: CachedModels 0.0.2 was a huge mess.

  It was a broken version, due to wrong mocks in test. I apologize for all the problems you could encountered using it. Since I discovered all the errors, I worked hard to restore all the lost functionalities.
  But it wasn’t enough for me, so I focused my attention on performances, reducing cache accesses: now benchmark test tooks 36.015132 fewer seconds than plain ActiveRecord!



Cached Models 0.0.2
Fri, 10 Oct 2008 00:00:00 +0000
CachedModels hit 0.0.2.
First of all, I transformed it to a Ruby gem, so you can use it outside Rails! Second, I dramatically enhanced performances, avoiding useless cache lookups and expirations. Take a look at the new benchmark stats: 1000 requests with a level of concurrency equal to 100, tooks 6 fewer seconds, if compared with standard ActiveRecord.
I strongly encourage you to upgrade to the newer version.


Released Sashimi 0.2.1
Mon, 29 Sep 2008 00:00:00 +0000
I’ve just released a new version of Sashimi (0.2.1), it fixes a bug for Ubuntu.
The Problem

  When the script starts tries to load repository concerned classes: GitRepository and SvnRepository, which are subclasses of AbstractRepository. In repositories.rb I use Dir#[] to load all the .rb files in a certain directory, but the order of the resulting array is unpredictable, so if the first class was not AbstractRepository Sashimi was crashing.

The Solution

  I’ve fixed it, so, if you have experienced this problem, please update Sashimi with:

$ (sudo) gem update sashimi
  



Cached Models
Wed, 10 Sep 2008 00:00:00 +0000
cached_models provides to your models a transparent approach to use Rails internal cache mechanism.

  Usually, when you decide to use cache for your ActiveRecord results, you have to manually implement complex expiring policies.
  cached_models simplifies your code:

class Author  true
end
class Post  true
end

That’s all!!.


  A more complex example..

class Project  true
has_many :tickets, :cached => true
has_many :recent_tickets, :limit => 5,
:order => ‘id DESC’, :cached => true
end



Ruby Time marshaling bug in pre-1.9
Fri, 29 Aug 2008 00:00:00 +0000

  Ruby’s Time has a bug: when try to serialize an timezoned time, then unserialize it back, the result will use the server local time, instead of use the original time zone.

>> utc = Time.now.utc
=> Fri Aug 29 09:07:37 UTC 2008
>> marshaled = Marshal.dump utc
=> "\004\bu:\tTime\r\251\037\e\200\344\254T\036"
>> Marshal.load marshaled
=> Fri Aug 29 11:07:37 +0200 2008



This bug doesn’t affects Ruby 1.9, but we still don’t use that version for production purpose. If you use 1.8.x with Rails 2.1.0, your cached timestamps (including ActiveRecord objects), are probably wrong.

>> comment = Comment.first
=> #<Comment id: 865423346, post_id: 1, text: "Nice post.", created_at: "2008-08-29 09:27:48", updated_at: "2008-08-29 09:27:48">
>> Rails.cache.write('comment', comment)
=> true
>> Rails.cache.read('comment')
=> #<Comment id: 865423346, post_id: 1, text: "Nice post.", created_at: "2008-08-29 09:27:48", updated_at: "2008-08-29 09:27:48">
>> comment.update_attributes :text => "Nice post!"
=> true
>> Rails.cache.write('comment', comment)
=> true
>> Rails.cache.read('comment')
=> #<Comment id: 865423346, post_id: 1, text: "Nice post!", created_at: "2008-08-29 09:27:48", updated_at: "2008-08-29 11:28:42">

Look at the last updated_at attribute, it uses local time instead of UTC time zone.

The first time everything goes right, because #updated_at wasn’t invoked and casted to a Time instance. It’s a string, and the marshaling is ok.

But, when I update the object, ActiveRecord changes the value of that timestamp, but before, it cast it to a Time, and everything goes wrong.


Click To Globalize: Ready for Rails 2.1!
Mon, 21 Jul 2008 00:00:00 +0000
Click to Globalize is ready for Rails 2.1!

  I spent a lot of time to make this release the best of ever! I know that a lot of time has passed since the latest Rails major release, and I apologize for this.
  The official Globalize it seems dead, but the great work of Nate Clark (aka heythisisnate) has made it compatible with Rails 2.1. Thanks Nate!
  The Rails Edge now includes a basic support for i18n!



Sashimi 0.2.0!
Mon, 14 Jul 2008 00:00:00 +0000
Sashimi has just hit 0.2.0!
This release has no sugar for you! No new features, just test improvements and code robustness.


Sashimi: Getting Started Tutorial
Mon, 30 Jun 2008 00:00:00 +0000

  Here a getting started tutorial for Sashimi.
  



Released Sashimi 0.1.6
Mon, 23 Jun 2008 00:00:00 +0000
I just released a new version of Sashimi, with tiny fixes and a new home!~
In fact the project is also hosted on RubyForge, now you can install the gem with:

$ (sudo) gem install sashimi


or with:

$ (sudo) gem install jodosha-sashimi --source=http://gems.github.com


If you wish, you can visit the project pages on GitHub and on RubyForge.
UPDATE The release 0.1.6 is broken, you are strongly encouraged to update your gem with the newest 0.1.7.


Speaker at RailsConf Europe 2008
Wed, 18 Jun 2008 00:00:00 +0000
I’m proud to announce my presence as speaker at the RailsConf Europe 2008 with a speech on Click to Globalize.


Rails: Single File App
Tue, 03 Jun 2008 00:00:00 +0000
I took inspiration from the Pratik Naik post, and realized a more simplistic version of its Rails single file app. My implementation has only Rails as unique dependency.

require 'rubygems'
require 'action_controller'
require 'webrick'
require 'webrick_server'
class HelloWorldController  ‘Hello World!’ end
end

ActionController::Routing::Routes.draw do |map|
map.root :controller => “hello_world”
end
DispatchServlet.dispatch :port => 3000,
:server_root  => File.dirname(FILE)


Update 2008-06-04: I just wrote another version which also uses ActiveRecord and a template.

require 'rubygems'
require 'activerecord'
require 'action_controller'
require 'webrick'
require 'webrick_server'
ActiveRecord::Base.establish_connection(
:adapter  => ‘sqlite3’,
:database => ’tiny_rails.sqlite3’,
:timeout  => 5000)



Ruby: Class Methods Proxy
Thu, 29 May 2008 00:00:00 +0000

  Did you ever used class methods inside your instance methods? If yes, you probably noticed how frustrating can be to use the self.class.my_class_method syntax. A solution could be to create a private method which encapsulates the class one.

class Repository
  def self.path
    @@path
  end
def print_path
puts path
end

private
def path
self.class.path
end
end


In the above example, #print_path can print the @@code value, without worrying about it’s a class value, because we have wrapped it.


Faster JavaScript Trim
Wed, 28 May 2008 00:00:00 +0000
I’ve recently discovered the very interesting Steven Levithan post about the JavaScript’s trim function of the String class.

  So, here my version:

function trim13 (str) {
  var ws = /\s/, _start = 0, end = str.length;
  while(ws.test(str.charAt(_start++)));
  while(ws.test(str.charAt(--end)));
  return str.slice(_start - 1, end + 1);
}


More numbers, please!

  I tested my function against the benchmarking page of the original post.
  Note: times are expressed in MS and are the average of ten executions per browser.
  Update [2008-05-29]: I re-runned all the tests and updated results, because Steven noticed that test suite was wrong (few whitespaces).
  


Sashimi: Just Received A Tasteful Update
Tue, 20 May 2008 00:00:00 +0000
On yesterday I announced Sashimi and now it’s already time of tasteful updates.
Changes
First, thanks to all the people that appreciated my work. Second, new commands and options are avaliable for Sashimi.
Update all plugins in your repository:

$ sashimi update --all


Install a plugin to your Rails app:

$ sashimi install --rails click-to-globalize

NOTE this is an alias for the add command.

Update a plugin of a Rails app:

$ sashimi update --rails click-to-globalize

NOTE If your application is versioned with Svn or Git, Sashimi will automatically schedules for add/remove the added/removed files.



Sashimi: A Rails Plugins Manager Gem
Mon, 19 May 2008 00:00:00 +0000
I have a really, really bad memory: each time I need to install a Rails plugin, I Google to find the repository, then try to download the code. Often, I remember the url, but the server is down. Damn!
All this annoying issues kill the Rails rapidity on application prototyping. But, what if all the plugins which I need are available offline on my notebook? I can forget about all that urls, and I should stop to worry about the server status.


Acts As Resource: Rails 2.1 ready and moved to GitHub
Wed, 14 May 2008 00:00:00 +0000
Acts As Resource is ready for the imminent Rails 2.1!
I also moved it to GitHub, the new repo is http://github.com/jodosha/acts-as-resource/tree/master, the SVN one is deprecated.
If you enjoyed this post, feel free to recommend me on Working With Rails.


Click to Globalize: rewritten and moved to GitHub
Mon, 12 May 2008 00:00:00 +0000
Click to Globalize has been rewritten, in order to use all instance methods of the JavaScript class, instead of class methods.

I also fixed some tiny issues: 
The form_authentication_token method is called only if the application is protected against the CSRF attacks (protect_against_forgery? returns true)
It uses as parameter key what request_forgery_protection_token returns, instead of the hard-coded authenticity_token
The JavaScript class uses Prototype’s dom:loaded custom event.
I also migrated the plugin GitHub. The new repo is http://github.com/jodosha/click-to-globalize/tree/master, so the oldest one is deprecated.
Have a nice globalization!


Ruby on Rails: Test Model Domain Changes
Mon, 28 Apr 2008 00:00:00 +0000
You know how tests are fundamental for a well-developed project, for this reason we should create step-by-step a net of test cases. Of course we also should be able to change rapidly our tests as the same we do with our code. Ruby on Rails is a great framework, because its shortcuts, the wide usage of DSL etc.. All this stuff can save a lot of time, but what about tests? Are we really able to follow our code?


Bit.Fall
Fri, 04 Apr 2008 00:00:00 +0000

Bit.Fall by Julius Popp.


Make your elements draggable and resizeable with Resizeable.js
Wed, 19 Mar 2008 00:00:00 +0000
Hello, I’m still alive and I want to share a useful JavaScript class: Resizeable.js. It allows to make draggable and resizeable your DOM elements!
How it works?


new Resizeable('element');


Your element has now two sensible areas: the border area and the central area. If you click on the central area and move the mouse around, keeping the left button pressed, your element will be dragged. If you are on the border area, and perform the same gesture, your element will be resized.


Ruby: XML Parsing With SAX
Wed, 30 Jan 2008 00:00:00 +0000
SAX is an event-driven parser for XML.
It sequentially reads the xml and generates special events. So, if you want to use SAX, you should implement the code to handle them. It’s quite different from the DOM model, where the whole xml is parsed and loaded in an tree.
As you can see, the first approach is more difficult than the DOM one. Why we should use it? Depends.
If you want to extract certain informations from a big file, probably you should choose a SAX implementation, in this way you can avoid the initial DOM loading overhead.
The Ruby XML Library
The Ruby core library has a built-in XML parser (both DOM and SAX) called REXML, but it’s terribly slow, it’s highly advisable to use libxml. It’s a binding to the popular library from Gnome and it was released as gem.


Click To Globalize: High Resolution Video Tutorial
Sat, 26 Jan 2008 00:00:00 +0000

The video tutorial for Click to Globalize is now available in high resolution: Click To Globalize: Getting Started.


MondoPOP
Sat, 05 Jan 2008 00:00:00 +0000

MondoPOP is a permanent expo of Pop toys, located in Rome.
I’ve been there a month ago, and I was fascinated about this new wave of artists, writers and crews. I think it’s a great think, to support this kind of projects: people who transform their passion in a work.
Good luck, guys!!


Ruby: How To Avoid A respond_to? Call
Wed, 02 Jan 2008 00:00:00 +0000
I’m writing this post as contribution to the Campagna Anti-IF (Anti-IF Campaign).
Problem
I’m developing an internal Rails plugin for widgets, it provides a class called Widget (really unconventional :-P), and each widget should inherit from it.
The actual implementation provides a callback called before_render, that allows to add some logic to a widget, if implemented it’s called before the widget rendering.
Ruby doesn’t have abstract methods, so I have to check if the subclass has the implementation of mentioned method:

    # Rendering code..
    before_render if respond_to? :before_render
    # ...




Rails: How To Create Custom Validations
Fri, 21 Dec 2007 00:00:00 +0000
Often our model objects leaning toward to be confused or noisy, due to validations DSLs. Imagine a class Answer, with an attribute, that should be exactly a string representation of a boolean. Ok, I know it’s an odd example, but: it’s trivial enough to make this example clear, and.. It happened to me to deal with this situation. :-P


    class Answer  %w( true false ),
                             :message => "Should be exactly true or false."
    end




Rome JavaDay 07: Slides
Wed, 19 Dec 2007 00:00:00 +0000
JRuby e DSLView more presentations from jodosha.

The Rome JavaDay 07 staff has created a Slideshare group.
I have already uploaded my presentation about: JRuby and DSLs.


Subsonica in Rome
Wed, 19 Dec 2007 00:00:00 +0000


I met Subsonica during a dj-set in Rome.
You can find my shots here.


Click To Globalize: Rails 2.0 Ready
Fri, 14 Dec 2007 00:00:00 +0000
I have finished to work on Click To Globalize, to made it Rails 2.0 compatible.
What’s Changed?
All and nothing: from the user point of view, the plugin has the same behaviors of the previous version. My recent activity was a refactoring, now it:
  
Works with CSRF Killer
    Works with Prototype 1.6.0.1 and Scriptaculous 1.8.0.1
    Works with rewritten version of Scriptaculous Ajax.InPlaceEditor
    Works with new Prototype events handling
    Uses new Prototype’s Element#addMethods and Function#wrap to add methods and AOP
    Uses Protoype Hash#get, instead of square brackets
    Uses .html.erb as helper, instead of .rhtml
    Has a more clean installation/disinstallation process
    Has DRYed up tests
    Hasn’t prototype.js into the packaging
  
How To Use It?

  Rails 2.0

    $ ./script/plugin install http://dev.23labs.net/svn/rails/plugins/click_to_globalize/trunk
  
Rails 1.2.x

    $ ./script/plugin install http://dev.23labs.net/svn/rails/plugins/click_to_globalize/branches/for-1.2.x
  
For a detailed guide, howtos, snippets, video-tutorials and other infos, please visit the Click To Globalize page.


Acts As Resource: Rails 2.0 Ready
Sun, 09 Dec 2007 00:00:00 +0000
Acts As Resource is ready for Rails 2.0!!
This plugin combines both ActiveRecord and ActiveResource features in one class. It easily allows to deal with a remote REST service or with a local database.
If you want read more visit the plugin page or install with:

    $ ./script/plugin install http://dev.23labs.net/svn/rails/plugins/acts_as_resource




Click To Globalize: Working On Rails 2.0 Compatibility
Sun, 09 Dec 2007 00:00:00 +0000
As you already know, Rails 2.0 it’s shipped with updated version of Prototype and Scriptaculous.
Prototype team has committed some breaking changes (e.g. Hash class), and Scriptaculous now has a brand new, rewritten InPlaceEditon.
Those elements are fundamental for Click To Globalize and I’m working on new version for Rails 2.0.
Be patient, I’ll soon release it.


Ruby on Rails 2.0: Released
Sat, 08 Dec 2007 00:00:00 +0000
As I previously announced Ruby on Rails 2.0 was released.
What’s new?
Active Record
Performances
    Sexy Migrations
    Foxy Fixtures
    XML Deserialization
    JSON Serialization
    acts_as Plugins Removal From Core
    Database Adapters Gems
    with_scope Protection
  
Action Pack

  
Resources
    REST Improvements
    Multiview
    Record Identification
    HTTP Loving
    Security Improvements
    Exception Handling
    Cookie Store Sessions
    New Request Profiler
    AtomFeedHelper
  
Active Resource
Official Inclusion In Core
    Remote CRUD
  
Action Mailer

  


Ruby on Rails 2.0 Will Be Soon Released
Thu, 06 Dec 2007 00:00:00 +0000
Ruby on Rails 2.0 will be released in the next hours!!


Pop Art!
Mon, 03 Dec 2007 00:00:00 +0000

In the last week-end I was at the Pop Art! exposition.
More than 50 artists (including Warhol, Lichtenstein and Rauschenberg) 100 works, from 1956 and 1968, for trace the history of the pop art movement.


Subsonica Live In Rome
Mon, 03 Dec 2007 00:00:00 +0000
Subsonica is one of my favourite band. It’s a Torino based pop electronic quintet, that just turned 10 years of activity.
They just posted a video of their recent dig in Rome. I was there, near the stage. Great experience!!



Acts As Resource: Combining ActiveRecord and ActiveResource
Wed, 28 Nov 2007 00:00:00 +0000
Would you use both ActiveRecord and ActiveResource in one class?
  Now with Acts As Resource you can!!
Example

  class Carrot
    acts_as_resource
    self.site = 'http://localhost:3000'
belongs_to :bunny

validates_presence_of :color
validates_uniqueness_of :color
validates_length_of :color, :within =&gt; 2..23,
                    :if =&gt; lambda { |c| c.color &amp;&amp; !c.color.empty? }
validates_format_of :color,
                    :with =&gt; /[\w\s]+$/,
                    :if =&gt; lambda { |c| c.color &amp;&amp; !c.color.empty? }

before_create :please_call_me_before_create
def self.validate
  logger.debug("VALIDATE #{color}")
end

def please_call_me_before_create
  logger.debug("Ohhh, so you called me..")
end

end



Ruby: Read A File With One Line Of Code
Tue, 27 Nov 2007 00:00:00 +0000
This snippet shows how to read a file and puts all the lines into an array.

    f = *open('file.txt').map {|l| l.rstrip}
    # => ["Hi, from the", "txt file."]

Explanation
The open method returns an IO object, that include the Enumerable module, now we can just use #map (or #collect).
The splat operator is only a sugar syntactical shortcut for map.


Rome JavaDay 07
Wed, 21 Nov 2007 00:00:00 +0000
I’ll be at the Rome JavaDay 07 as speaker, with a presentation on JRuby and DSL.
See you at the conference!!


Rails: How To Modify Template Contents Before Rendering
Thu, 15 Nov 2007 00:00:00 +0000
Just a quick snippet to modify template contents before ActionView render them via ERB.

    ActionView::Base.class_eval do
      alias_method :action_view_render_template, :render_template
      def render_template(template_extension, template, file_path = nil, local_assigns = {})
        template ||= read_template_file(file_path, template_extension)
        template = "#{template}" # add your contents here.
        action_view_render_template(template_extension, template, file_path, local_assigns)
      end
    end

You can add this code to environment.rb, but is preferible a plugin.


Parallels: How To Install Ubuntu 7.10
Sat, 03 Nov 2007 00:00:00 +0000
This is a guide to install Ubuntu 7.10 (Gutsy Gibbon) on Parallels 3.0 and Leopard.
Configuration
MacBook 13”
  Intel Core Duo 2Ghz
  1Gb RAM
  80Gb HD
  MacOS X 10.5 (Leopard)
  Parallels 3.0 (build 5160)
Preparation
If you have installed Leopard you should upgrade your Parallels version at the build 5160 (Leopard Support).
Installation
Download the disk image (ubuntu-7.10-alternate-i386.iso) from the Ubuntu website.
  Start Parallels and choose Typical, then Linux from OS Type and Ubuntu Linux from OS Version.
  Specify a name for the virtual machine: Ubuntu Linux 7.10.
  Optimize for better performance of: Virtual machine.
  Click on More Options, then select ISO image and choose the disk image.
  Now should start the installation process: choose Install in text mode from the first screen.
  Choose your language and locale. When prompt for the keyboard layout detection, choose no. Now should appear a page to pick the keyboard layout. On the following screen do not select the Macintosh layout.
  Network configuration: enter the name of the computer.
  Partition disks: choose Guided - use entire disk and set up LVM. On the following screen choose Yes, then Finish partitioning and write changes to disk. Don’t worry about disk dimension, the LVM don’t really use that space.
  Choose your timezone.
  Setup an user.
  Have a coffee.
  Optional: If the installation process prompts for the download of your language pack, install it now.
  Screen resolution: 1280x800.
  Take a break.
  Installation complete: choose Continue. This should reboot your virtual machine.
  Login, click on the Network Connection icon, then choose your connection. This should activate your LAN connection.
  Click on the Updates icon, then upgrade your system.
Done
Now your Linux box should be ready. Feel free to comment if something goes wrong.


Kubrik exhibition
Tue, 30 Oct 2007 00:00:00 +0000

Sunday I went to a Stanley Kubrik exhibition in Rome. He is one of my favourite directors.
The exhibition is full of screenplays, shots and things regarding his movies. It was very exciting!!
If you are in Rome you can visit Palazzo delle Esposizioni until the Jan 6th, 2008.


Rails To Italy 07 Updates
Fri, 26 Oct 2007 00:00:00 +0000
Rails To Italy 07 conference has just started, stay tuned.
UPDATE: 10:38
Sorry, network problems Zed Shaw, has finished his keynote.
James Cox now is talking about Rails scalability
UPDATE: 14:37
Waiting for Thomas Fuchs!!
Sorry, but in the past two days we have had a lot of network problems.


Rails To Italy 07 - Q&A Session with DHH
Tue, 16 Oct 2007 00:00:00 +0000
Rails To Italy 07 will have a Q&A session with David Heinemeier Hansson, the creator of Ruby on Rails.
If you want to ask something to him, just send a mail to program@railstoitaly.org, the organization will select the questions.


Rails: How to force plugins loading in 2.0
Mon, 08 Oct 2007 00:00:00 +0000
Sometimes a Rails plugin can be dependant from another one. Since plugins are loaded in alphabetic order, probably you need to load the third part plugin first.
The release 1.2.4 2.0PR introduces breaking changes for this mechanism.
I’m developing a plugin called ClickToGlobalize, that’s dependant on Globalize, here the code for plugin initialization:

    # Force Globalize loading.
    if Rails::VERSION::STRING.match /^1\.2+/
      load_plugin(File.join(RAILS_ROOT, 'vendor', 'plugins', 'globalize'))
    else
      Rails::Initializer.run { |config| config.plugins = [ :globalize ] }
    end
require 'click_to_globalize'


Explanation
Use the old mechanism if the current release is minor than the last release with it (1.2.3 1.2.4), else use the Rails::Initializer class.


JPG Magazine: Emotion Capture theme
Fri, 05 Oct 2007 00:00:00 +0000
I’m partecipating to the Emotion Capture theme on JPG Magazine with this photo:

How to vote
Please register yourself on JPG Magazine, then go to the photo page and vote. The contest deadline is Dec 12th.


Ruby: How to check the operating system
Fri, 05 Oct 2007 00:00:00 +0000
Today I’m finishing the code cleanup for my latest Rails plugin (will be soon released) and I want to execute some rake tasks, only if the OS supports certain system calls.
The following snippet helps to check the current platform.

    # (c) 2007 Luca Guidi (www.lucaguidi.com) - Released under MIT License.
    # This code was inspired by Prototype rake test tasks.
    require 'webrick'
class OperatingSystem
  class  </code>



Rails To Italy 07 - Coding Challenge
Tue, 25 Sep 2007 00:00:00 +0000
Coding Challenge
The Rails To Italy conference has started a Coding Challenge. The topic will be “Your Favourite Thing” - create a small, interactive web application that is related to your favorite thing or activity*.
Prizes
Prizes are 1 iPhone or iPod touch + 2 iPod shuffle!
Deadline
Submission deadline is the 20th October 2007.
[Rails To Italy 07 - Coding Challenge]


Brand new blog
Mon, 03 Sep 2007 00:00:00 +0000
I have migrated my blog from the old one to this system, please follow here my articles and posts.
That blog will not be updated.
Thanks, Luca.


Javascript Alias Method
Mon, 03 Sep 2007 00:00:00 +0000
Working with a dynamic and complete language like Ruby, I feel the lack of many native methods. Lately, I’m working-by-plugin  implementing new code, and injecting it into the old one from Rails or Prototype, and so on..
It’s a very nice and grateful way of add and remove features on the fly, and change the aspect of the code.
In fact this kind of tecniques and programming paradigms are also called AOP, due to the capability to change the aspect of an object, and, of course, its behaviors.
For this purpose, I feel very useful the Ruby alias_method. Of course, it’s a way to create an alias, and eventually override that method, and reuse the brand new name into the old one!!
So playing around a bit with Javascript, I have add this feature to the Object class:

    Object.aliasMethod = function(object, newMethodName, oldMethodName) { 
      object[newMethodName] = object[oldMethodName]; 
    };

Here a little example:

String.prototype = Object.extend(String.prototype, {
capitalize: function() {
return ‘The capitalized version of ‘+this+’ is: ‘+this.aliasedCapitalizeMethod()+’.’;
}
});



Flickr pro-account
Wed, 25 Apr 2007 00:00:00 +0000
I’ve just bought a flickr pro-account, now I can upload a tons of shots..
PS: this is my account page: jodosha


ActiveForm 0.2.0 released
Wed, 28 Mar 2007 00:00:00 +0000
ActiveForm is a JavaScript library, based on Prototype, useful to validate
your forms in an automagically and pluggable way.
Automagically? Simply, You have to declare your fields, eventually your error messages, and.. nothing else!!
Pluggable? ActiveForm contains most common validations (regular expressions, presence, conditional presence..),
and it performs them in a certain order. If you don’t like this, you can simply redeclare a method, or exclude it from validation process.
Features:



Highrise
Tue, 20 Mar 2007 00:00:00 +0000
37signals officially launced Highrise.
It’s a new organization service, to share contacts and tasks with your team or your friends. It allows to to track people, phone calls, events, and also supports mail tasks.
I’ve just signed up.


Twittervision
Sun, 18 Mar 2007 00:00:00 +0000
Twittervision is a simple mashup of Twitter and Google Maps. It allows to geolocate twitters entries.
To change your location you must send an update, using L: operator, followed your location. I.e.: L:Florence, Italy.
You can also “tag” your location: home, work, school, club..
It’s very cool, and causes an high addiction.



Play random files with Ruby
Fri, 02 Mar 2007 00:00:00 +0000
I’ve written a class to play random files, you can define the player path and allowed file extentions.
It will search recursively for all readable files, starting from execution from the folder passed as argument or, if miss, from current folder. Tested on a linux box with mplayer.

Usage:

    $ ./shuffle
    # play recursively all files from current folder
    $ ./shuffle /path/to/files
    # play recursively all files from specified folder


That’s the source code.

#!/usr/bin/ruby



Little Miss Sunshine
Mon, 26 Feb 2007 00:00:00 +0000
Little Miss Sunshine has won two oscars!!
I’m very happy, I have watched this movie just a week ago, and I like it.
It’s a nice story about an odd american family that cross the US aboard an old volksvagen van. It’s funny, it’s sad, it’s sweet. You have to see it.


Ruby on Rails: Validate URL
Wed, 21 Feb 2007 00:00:00 +0000
Hi, just a snippet to validate an url with Ruby on Rails.

    class WebSite  /^((http|https):\/\/)*[a-z0-9_-]{1,}\.*[a-z0-9_-]{1,}\.[a-z]{2,4}\/*$/i
  def validate
    errors.add(:url, "unexistent") unless WebSite.existent_url?(:url)
  end

  def self.existent_url?(url)
    uri = URI.parse(url)
    http_conn = Net::HTTP.new(uri.host, uri.port)
    resp, data = http_conn.head("/" , nil)
    resp.code == "200"
  end
end




Shot A Day: 2007 January
Wed, 31 Jan 2007 00:00:00 +0000

My 2007 January roundup on Shot A Day project.

Look at whole gallery at my page on flickr.



MPlayer console tip
Wed, 17 Jan 2007 00:00:00 +0000

I’ve discovered an interesting tip for MPlayer to play all folder’s media files. enter:

    mplayer *


It automatically enqueue your files.
If you use fast forward (up key) mplayer treats your playlist like one file, so you can navigate between your files. Unfortunately it works only with forward seek.



Javascript HashMap
Mon, 30 Oct 2006 00:00:00 +0000
Reading around i’ve discovered that Javascript associative arrays returns unpredictable results, i.e. length param is not correctly handled.
Array object should be used only with a numeric index and best way to avoid this problem is to use Object.
But, if I wanna put more objects in my object?
Of course i can do this with previous method, but i don’t like it :-P. So, i’ve written a 100% OOP class, that use Prototype and it simulate a java HashMap.


Welcome to my blog!!
Thu, 16 Mar 2006 00:00:00 +0000
Welcome to my blog!!


Sponsors
Mon, 01 Jan 0001 00:00:00 +0000
My Work
I’m working hard every day for 15 years to keep Ruby Community vibrant.
That includes speak at conferences, create screencasts, write blog posts, and play a role in Open Source.
During these years, I contributed to several important Open Source projects like Ruby on Rails, Rack, redis-rb, lego, and created my own: Hanami and redis-store.
I’m in the dry-rb core team as well.
I’m currently working on Hanami 2 and Hanami::API 1. 🌸
Sponsors


Sponsorship
If you want to support my initiatives, please consider to sponsor me via: GitHub Sponsors.


What I'm doing Now
Mon, 01 Jan 0001 00:00:00 +0000

Luca Guidi

Why Your `app version` Golang CLI Command Loads Your Database Client (And How to Fix It)

Setup Hanami with Sidekiq

Introduction

Steps

1. Add the Sidekiq gem

2. Add a Sidekiq provider

Getting Started with Hanami and Docker Compose

Introduction

Steps

1. Generate the app

Getting Started with Hanami and GraphQL

Introduction

2022: A Year of Growth and Accomplishments

Striking a Balance: Why Prioritizing Both People and Processes is Key to Success in Agile Teams

Open Source Updates: Q1 2021

Hanami CI stability

Open Source Updates: December 2020

Brief 2020 recap

Ruby Method Overloading

Hanami::API on Amazon AWS Lambda

Introducing hanami-cli

Why not thor?

How To Test Ruby CLI: Console

Console

How To Test Ruby CLI: Code Generators

Code Generators

How To Test Ruby CLI: The Setup

Full Isolation

Lessons Learned In Open Source: The Motivations

Isolate Global State

An Example Of The Problem

The Penguin That Can't Fly

A short story about OOP, interfaces and soft typing

25,000+ Req/s for Rack JSON API with MRuby

JSON API Apps With Lotus

Effective TDD With Ruby: Tmux Setup

Effective TDD With Ruby: Vim Setup

Effective TDD With Ruby: Time & Flow

Effective Remote Working

Lotus And Microservices

The monolith is good (at the beginning)

A New Roadmap For Lotus

Learn from mistakes

2014 Retrospective: A Year Of Lotus

Introducing Lotus::Validations

Meaningful Exceptions

Introducing Lotus

Three Things To Know About Composition

Rails Is Not Dead

We Are All Wrong About Software Design

Introducing Lotus::Model

Thread Safety With Ruby

Introducing Lotus::View

Redis Scripting with MRuby

Introducing Lotus::Controller

Actions

Building Sinatra with Lotus

Initial setup

Introducing Lotus::Router

Announcing Lotus

Standalone frameworks

On Happiness

What really works is to plan nothing

Introducing Redis Store

Lean Rails App Setup

HTML5 Geolocation Testing with Cucumber

Why Customer Service Matters

How to install ruby-debug on Ruby 1.9

Rails: Unobtrusive and i18n Javascript confirm

Memoria: Statistics for Redis

Hanoi: Automated jQuery tests with QUnit

Click To Globalize for Rails 2.3

Engine

I18n

RESTful

Lightweight

Formatting

Deprecations

Boost Rails Sessions

Why not `thor`?