I was impressed with a great work done by Geoffrey Grosenbach from PeepCode or guys like Bill Dudney or Ryan Bates who publish their recordings under Pragmatic Programmer umbrella. I have bought almost all material they have produced and it was money well spent.

After watching a few of their episodes I understood I would love to follow into their footsteps and start to produce my own screencasts. A few months later, working after hours I finished my online store and recorded Stripes fundamentals.

It is the first out of a series of screencasts that map out how to use Stripes to solve everyday web application development challenges in a simple and efficient way. The whole series is based on application-centric approach where the development of an online shop application drives the coverage of Stripes.

At code quest I don’t want to focus only on one domain or technology. The upcoming screencast will be dedicated to deployment on Ubuntu. I am recording it together with my friend Piotr Maj and it should be available by the end of May. Please stay tuned!

I hope screencasts published at code quest will help developers learn in a fast and efficient way. My goal is to produce high quality stuff at a reasonable price. And my hope is that you’ll help me achieve this goal. It is an agile project and you get to help steer.

I look forward to your feedback.

Recently, on a blog of one my friends, I have read a recommendation for Deadline by Tom DeMarco.

I fully agree with my friend that this easy, entertaining book provides some valuable ideas about how to improve a project and can be a great read for a software engineer who has been moved to project manager role.

In addition to Deadline I would like to recommend another book by Tom DeMarco I have just read - Adrenaline Junkies and Template Zombies.

Software engineers should be aware of elegant solutions to common problems in software design. They should know patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. They should also recognize and correct bad habits of code and design.

I believe the same story is with project managers.

Project Manger should know good patterns to follow and anti-patterns that should be avoided.

Tom DeMarco together with the team of his friends from the Atlantic Systems Guild has done a nice job and described 86 patterns of project behavior.

Patterns can be read in a moment. Each pattern is about two pages long with titles that build strong association in the brain… e.g. adrenaline junkies, dead fish, project sluts, template zombies…

You won’t be surprised how often you will say… “Ahh… I recognize it… somebody is spying on my company… this is exactly what is happening right now in my project…”

I strongly believe this is a fun, interesting read for all software engineers and project members and… definitely the must read for project managers who want to avoid pitfalls and boost effectiveness of their teams.

Adrenaline Junkies and Template Zombies can be consumed in an evening or during a longer flight with very little effort.

If you normally fall asleep while reading books about project management, give Adrenaline Junkies and Template Zombies a try. I am sure you won’t be disappointed!

In this blog post I would like to share with you how to minimize this repetitive code and make your form nice, concise and dry by writing custom form builders.

Let’s say you are building a new web application with your close friend. He is a ninja of css, a web standards orthodox and requires that application generate forms that look like the piece of html below.

<form action="/users" class="new_user" id="new_user" method="post">
<fieldset>
<legend>Sign up:</legend>
<dl class="required correct">
<dt><label for="user_login">Login</label></dt>
<dd><input id="user_login" name="user[login]" size="30" type="text" value="tomek" /></dd>
<dd class="notice">Lowercase letters (a-z) & numbers only - no spaces.</dd>
</dl>
<dl class="required error">
<dt><label for="user_email">E-mail</label></dt>
<dd class="error">can't be blank</dd>
<dd><input id="user_email" name="user[email]" size="30" type="text" value="" /></dd>
<dd class="notice">We won't get you spammed!</dd></dl>
...
</fieldset>
</form>

You are fully aware you cannot generate this kind of html with the standard helper methods provided by Rails.

On the one hand you don’t want to upset your friend and even start negotiations on how forms should be styled. On the other hand you would like to keep the code of your view concise and easy to maintain… let’s say more or less like the snippet below.

<% form_for @user do |f| -%>
<fieldset>
<legend>Sign up:</legend>
<%= f.text_field :login, :notice => "Lowercase letters (a-z) & numbers only - no spaces." %>
<%= f.text_field :email, :label => 'E-mail', :notice => "We wont get you spammed, we promise!" %>
...
</fieldset>
<% end -%>

Well… in tis situation… there is no other way. You have to write your own form builder!

What is a form builder?

ActionView::Helpers::FormBuilder is one of the “hidden hero” Rails classes. It is used on a frequent basis but not everybody realizes it even exists.

Whenever you use form_for helper in your view template, you pass an instance of FormBuilder class to the block associated with the method. Look at the snippet above. This is f variable.

So… if you want to create your own LabeledFormBuilder class with the enriched functionality all you need is to subclass ActionView::Helpers::FormBuilder and instruct Rails to use it. There are a few ways to do it.

One of the solutions is to create a new folder with Ruby file that will contain LabeledFormBuilder class and add it to load paths of Rails environment.

Let’s say you have just created a folder named builders with labeled_form_builder.rb file under app directory of your application. In order to tell Rails to load ruby code located in this place you have to add one line to your environment.rb file.

# app/config/envirnoment.rb
Rails::Initializer.run do |config|
...
config.load_paths += %W( #{RAILS_ROOT}/app/builders )
...
end

Next time you restart the server Ruby code placed in the labeled_form_builder.rb file will be loaded.

It is high time you rolled up your sleeves and wrote custom form builder!

Below I would like to show exemplary implementation that may help you to stay on speaking terms with your css ninja friend. I will also share a trick that I consider very useful and cool.

# app/builders/labeled_form_builder.rb
class LabeledFormBuilder < ActionView::Helpers::FormBuilder

  %w[text_field password_field text_area].each do |method_name|
    define_method(method_name) do |field_name, *args|
      options = args.extract_options!

      # Create field
      field = @template.content_tag(:dt, label(field_name, options[:label]))

      # Add validation errors
      field += field_errors(field_name)

      # Add field element
      field += @template.content_tag(:dd, super)

      # Add notice message
      field += @template.content_tag(:dd, options[:notice], :class => 'notice') if options[:notice]

      # Render field container with all elements
      @template.content_tag(:dl, field, :class => field_style(field_name))
    end
  end

  def check_box(field_name, *args)
    options = args.extract_options!
    @template.content_tag(:dl, super + label(field_name, options[:notice]), :class => "checkbox")
  end

private

  def is_required?(field_name)
    object.class.reflect_on_validations_for(field_name).map(&:macro).include?(:validates_presence_of)
  end

  def has_errors?(field_name)
    object.errors.invalid? field_name
  end

  def field_errors(field_name)
    field_errors = ''
    if has_errors?(field_name)
      object.errors[field_name].each do |msg|
        field_errors += @template.content_tag(:dd, msg, :class => 'error')
      end
    end
    field_errors
  end

  def field_style(field_name)
    field_style = ''
    if is_required?(field_name)
     field_style += 'required'
    end

    if has_errors?(field_name)
     field_style += ' error'
    elsif !object.errors.empty?
     field_style += ' correct'
    end
    field_style
  end    

  def objectify_options(options)
    super.except(:notice, :label)
  end
end

Now let me share a trick with you. Please look at is_required method. In the line…

# app/builders/labeled_form_builder.rb
...
object.class.reflect_on_validations_for(field_name).map(&:macro).include?(:validates_presence_of)
...

… I use validation reflection plugin to find out if a given field is required or not.

I also use a piece of metaprogramming to provide own implementation of text_field, password_field, text_area helper methods.

The only thing that is missing to make this little example work is intruction to Rails to use LabeledFormBuilder instead of the default one. There are two ways you can do it.

First of all you can add builder attribute to form_for helper.

<% form_for @user, :builder => LabeledFormBuilder do |f| -%>
<fieldset>
<legend>Sign up:</legend>
<%= f.text_field :login, :notice => "Lowercase letters (a-z) & numbers only - no spaces." %>
<%= f.text_field :email, :label => 'E-mail', :notice => "We wont get you spammed, we promise!" %>
...
</fieldset>
<% end -%>

Secondly you can go to your environment config file and add one line to register your custom form builder as the default one.

# app/config/envirnoment.rb
ActionView::Base.default_form_builder = LabeledFormBuilder

That’s all! Now you can send a message to your friend that his html code is safe and you can open bottle of wine

I was traveling around Argentina: learning tango in Buenos Aires, admiring glaciers in El Calafate, playing with whales and penguins in Puerto Madrid, watching the beauty of waterfalls and jungle in Iguazu and learning about history and culture heritage of Argentina in Salta.

Traveling is for me more about gathering new experiences rather than just pure relaxation. If a trip shook up my perception of the world and changed it a little then journey was a success.

My visit to Argentina was definitely successful. My perception of South America and Argentina in particular has changed.

I made friends with people from Chile, Peru and a few other countries, experienced the beauty of Argentina which I will try to share on the natrasie.pl.

I am sure I will come back to this part of the world. Don’t cry for me Argentina. I will be back!

Hasta la vista.

You want to change the world and make your application accessible to all good people out there… that’s why your a new-born baby has to speak several languages!

Now with Rails 2.2 it is easy! All you need to know is two API methods: I18n.transate aka I18n.t and I18n.localize aka I18n.l …and somebody who can help you with translation to exotic languages like Chinese, Thai or Polish.

In this post you will find a quick, step-by-step tutorial how to add internationalization to your Ruby on Rails application. Please be aware it is a very simple example and you have to “live on the edge” to fully benefit from this post… ok… no more fluff and let’s dive into code together!

First of all let’s create Rails app, freeze edge and create resource to test things out.

rails speak2me
cd speak2me
rake rails:freeze:edge
./script/generate resource friend
./script/generate migration AddNameToFriend name:string

Now it is time to create a directory named locales which will contain our translations….

mkdir config/locales

…and create there two translations for English and Polish language

# config/locales/en-US.yml
"en-US":
  main:
    hello: "Hello Darling!"
# config/locales/pl-PL.yml
"pl-PL":
  main:
    hello: 'Witaj Kochanie!'

In the release 2.2 of Ruby on Rails framework there was introduced the I18n module.

In the configuration file we will encapsulate details of what locales are available, where they are kept, and what is to be used as the default. Let’s create i18n.rb file under initializers directory.

# config/initializers/i18n.rb
I18n.load_path += Dir[ File.join(RAILS_ROOT, 'config', 'locales', '*.{rb,yml}') ]
I18n.default_locale = "en-US"

We have just configured I18n module and now it is right time to get use of it in our controller and view files.

First of all let’s add method to set locale. We will create a before_filter in the common base class for all of our controllers.

class ApplicationController < ActionController::Base
  before_filter :set_locale
protected
  def set_locale
    session[:locale] = params[:locale] if params[:locale]
    I18n.locale = session[:locale] || I18n.default_locale
  end
end

Next we will add index.html.erb file with localized version of greeting.

# views/friends/index.html.erb
<%= I18n.t "main.hello" %>

The only thing left is to update route configuration and test things out.

# config/routes.rb
ActionController::Routing::Routes.draw do |map|
  map.resources :friends
  map.root :controller => 'friends'
end

Open your browser and have fun… default locale is en-US but as soon as you change locale param you will get polish version of text.

I have mentioned that in order to localize you Rails 2.2 application you should be aware of two API methods: I18n.transate and I18n.localize.

So far we used only alias to one of the methods - I18n.t. So… what is a function of I18n.localize method?. Well.. this one basically allows you to format Date and Time objects for a certain locale. In order to see it in action we should update our file with polish locale and add one line in view file.

# views/friends/index.html.erb
<%= I18n.t "main.hello" %>
<%= I18n.l Time.now %>
# config/locales/pl-PL.yml
"pl-PL":
    main:
        hello: 'Witaj Kochanie!'

    date:
        formats:
            default: "%d.%m.%Y"
            short: "%e. %b"
            long: "%e. %B %Y"
            only_day: "%e"

        day_names: [Niedziela, Poniedziełek, Wtorek, Środa, Czwartek, Piątek, Sobota]
        abbr_day_names: [N, Pn, Wt, Śr, Cz, Pt, So]
        month_names: [~, Styczeń, Luty, Marzec, Kwiecień, Maj, Czerwiec, Lipiec, Sierpień, Wrzesień, Październik, Listopad, Grudzień]
        abbr_month_names: [~, Sty, Lut, Mar, Kwi, Maj, Cze, Lip, Sie, Wrz, Paz, Lis, Gru]
        order: [ :day, :month, :year ]

    time:
        formats:
            default: "%A, %e. %B %Y, %H:%M"
            time: "%H:%M"
            short: "%e. %B, %H:%M"
            long: "%A, %e. %B %Y, %H:%M"
            only_second: "%S"

        am: "przed południem"
        pm: "po południu"

That’s all folks!

For more details about internationalization in the latest version of Ruby on Rails I strongly recommend to visit Sven Fuchs’s blog. You will get knowledge directly from a source.

Well… to make the long story short, omnimemo is a service for people who would like to build rock-solid knowledge in a fast and efficient way.

I would like to implement application that will assist learner in his or her learning process.

It will learn how user learns. By building approximated model of user learning curve, omnimemo will compute optimum intervals between repetitions.

There are many factors that can be used to build model of learning curve and compute those intervals but in the first version of omnimemo I will focus on two main contradictory features.

• in the period of time frequency of repetitions should be as low as possible. The reason for that is that longer time between repetitions of certain material produces stronger association in the brain. This is so called spacing effect.
• … but students shouldn’t forget material before repetition, it means intervals between repetitions should be short enough to ensure that the knowledge is still remembered.

In the future versions of omnimemo I would like to combine local features specific to user learning process with the global features of the whole group of learners who try to master given pice of knowledge.

There is several algorithms and methods to choose from and experiment with. It will be interesting!

Apart from approximated model of user learning curve there are two more aspects that are equally important for me in the context of omnimemo.

First of all, I would like to embed in the omnimemo social aspect of learning process. I would like users to be able to share with their friends material they would like to master and enjoy spirit of collaborative learning. I remember when I was student that I had really good results when I studied with the group of my friends. We shared notes, materials and studied together. It was fun and effective!

Secondly, I would like to make it possible to learn almost everywhere. I would like to build version of omnimemo for mobile devices.

I definitely need version for my iPhone but I will also build version for Android because I like an idea behind this platform and would like to take this opportunity to master it while building sth useful.

There is still a lot of work in front of me but I strongly believe I can build sth that matters and brings value.

There are two things I am really passionate about: computers and brains.

I love to program, build software and see how few lines of code can create things that really matter or bring fun.

I also like to debug our mind. I am interested in how we learn, how our memory works, how we can improve it and get most out of our brain. I learn, experiment and read a lot of books in this area. Most of the things Andy presented during his talk in Sweden were nothing new to me… but the way he did it and the context he put it in was really valuable and enjoyable for me.

Last week I read the latest book by Andy Hunt “Refactor your wetware”. It is great book that is fun and really can help to become more effective in learning process!

Easy to read, very pleasantly written with a lot of of examples that are very valuable especially from the perspective of a software developer. It is great introduction to anybody who is interested in the learning process, how our brains are wired, and how to take advantage of our brain’s architecture. It contains ideas and useful tips on how to solve hard problems, get innovative ideas.

It doesn’t go into details of mnemonics, memorizing techniques or more scientific models of our brain and learning process which in my opinion is only an advantage of this book. Lecture is engaging and motivates to more research in the area.

It is a well structured story that in my opinion should be a must read for all software developers…. together with another book by Andy Hunt and Dave Thomas - Pragmatic Programmers.

I strongly encourage you to check this book out. Read it, enjoy it and dedicate yourself to lifelong learning.

Thank you Andy!

Technology develops and improves with the speed of light. Each year more and more research is done in the area of artificial intelligence, computer vision or pattern recognition. Unfortunately, there are still a lot of tasks that computers cannot solve yet and there is a huge need for human processing power.

Humans can identify objects in a photo or video much more effectively than computers. Humans can transcribe and translate podcasts, identify emotions, fill in questionnaires on a variety of topics. Still only humans can write valuable reviews and blog posts. Machines are not intelligent enough. At least not now.

A few months ago, inspired by work of Luis Van Ahn, I decided to build a game where as people play and have fun they help to solve one of the current challenges in the area of computer vision and content based information retrieval. They help to build a better world.

Snipetag is game with the purpose! The goal of the game is to retrieve semantics from images and gather data they will contribute to the research in the area of machine recognition of objects in the web of photos. All data will be available for free to any researcher whose work, research could benefit from it.

Don’t forget the most important thing! Each game you play helps a small, friendly alien lost on the Earth. Here is the story of Thomaso Marsjano.

Have fun and help to build a better world!

Ahhh… I build this application after hours, so please forgive me bugs. If you find an issue that has to be fixed please don’t hesitate to send me an email. I will fix it. Snipetag is one of my experiments and is now in BETA mode.

One of my travels had its beginning a few months ago. I shared an idea with my friend of building a web site where people could describe their travel experience in an intuitive and pleasant way, publish photos as well as keep track of their friends’ journeys and find out more about destinations before booking a trip.

The idea has caught up. Together with the small team of close friends we decided to invest our time and energy. We started a preparation for our first entrepreneurial travel!

For all of us it has been a new experience. What will be our final destination? What kind of obstacles will we encounter on our way? We still don’t know. The final destination is not the most important thing. What is really significant is new experience we all gain!

Real travel involves meeting people whose viewpoints are completely different from your own, finding out that you still have a lot in common, that you can communicate and learn a lot from one another. From this point of view work on the natrasie.pl is real travel.

natrasie.pl is built by friends and for friends. We hope that our passion and engagement will help us to organize valuable and interesting place on the Internet for our users.

I invite you to visit our website… and please share your experience. Psss… please forgive us bugs, we are in beta mode now.

Imagine you a serial entrepreneur and would like to conquer the world with a new, kicking ass web application. Digg, Face Book and My Space all rolled into one. You are going to a build perfect tool that will discover a relevant content for you and your friends all over the whooooooole web. It will be based on your intentions and intentions of your community. Your idea is great!!!. You can already see yourself on the cover of Wired magazine. You will be more popular than David Heinemaier Hanson, Britney Spears and David Beckham all together. You will be a super star. You ARE a super star!!!

You open you machine, start coding, implement the first pages of your application and then… Boom, bang, boom! The first problem crops up. How to group web sites, blog posts based on their content? How to retrieve semantics from them? How to cluster all this stuff? You google for the solution and after a while you find out that sth called Singular Value Decomposition may help. Old uncle Google says it definitely sounds like a good “candidate” to investigate. Unfortunately, you have to refresh your knowledge about linear algebra. It is awful but if you want to reach for the stars… No pain no gain!

Linear algebra comes with help - SVD

Today I would like to continue with a linear algebra refresher and introduce matrix decomposition with SVD.

Singular Value Decomposition is one of the cluster analysis and noise reduction technique introduced in 1965 by G. Golub and W. Raman. When we compute the SVD of a matrix the goal is to reduce matrix dimensionality by its decomposition into three components and keeping first k singular values. It will give us an approximated representation of the original matrix. A kind of compressed version of the matrix.

There are a lot of practical areas where SVD can be applied. In one of the next posts I would like to present the application of SVD in Information Retrieval where it is used in the process of Latent Semantic Indexing in order to search for documents that meet given query. It is one of the methods that can help in the analysis of text collections. For instance, blog post or other web content exposed to your next generation web application.

Before I share with you code to do all the stuff please grab your pencil plus a notebook and let me share with you in the next few lines how is singular values decomposition computed and approximation of the matrix built.

SVD decomposes matrix into three components: A = USV^T

• U - matrix whose columns are the eigenvectors of the AA^T matrix - called the left eigenvectors
• S - matrix whose diagonal elements are the singular values of A. Please note it is diagonal matrix so its all non-diagonal elements are zero
• V - matrix whose column are the eigenvectors of the A^TA matrix - called the right eigenvectors

Okey-doke… nice definition but how does it work? Let’s say we have matrix A

The first step is to compute a A^T. If you would like to refresh your memory about matrices and matters related to them please have a look at Matrix cookbook Part 1 and 2. All you have to know is how to transpose matrix and multiply two matrices.

As soon as we have A^T and A^TA the next step is to obtain singular values of the matrix. In order to do it we have to compute the eigen values of A^TA, sort absolute values of them in descending order and just after that place them on the diagonal of S matrix. Don’t worry, it is easy. Actually, all you need to do is to solve a polynomial equation. Let’s have a look at all the calculations.

Singular values of the matrix are computed. We can construct S matrix.

Fresh coffe on the table and now we are ready to compute V

We will use eigen values of the A^TA matrix we have just computed and construct eigen vectors.

Let’s do it for x = 13.32

Let’s repeat the exercise but this time for x = 0.67

There we go… We are almost done. Now we have to place eigenvectors on V matrix and transpose it.

At this point we have to the same calculation but for AA^T matrix and compute U matrix.

…time for U2

Here we go. Matrix reloaded

We have computed U, S and V^T. Now we have to write unit test… hmm… Please grab your pencil again and check with me if USV^T is the approximation of matrix A.

It looks good. We have decomposed matrix A into three matrices. But… why do it? How can we benefit from it? We will benefit from it as soon as we built compressed version of the matrix A. In our simple example the matrix is 2-dimensional. Imagine you deal with a matrix with huge dimensionality. Imagine “gazillions” of dimensions and a lot of noise there. It is a situation where you definitely would prefer to deal with approximated version. Fortunately, building an approximation of the original matrix is piece of cake. It is done by truncating the three matrices obtained from a full SVD. All we keep are the first k columns of U, the first k rows of V^T and the first k rows and columns of S. As soon as we have done it, we get a compressed version of the matrix A.

There is more to come…

In the next post I will share with you how to apply SVD in the process of Latent Semantic Indexing. You won’t even need a pencil or a notebook. This time we will write some code. Let’s apply theory in practice.

I also plan to continue an idea of building the next generation web content filter and focus on data mining techniques that can be useful on the way.

Stay tuned. There is more to come.