J-kanban 玄人志向 » RailsOnWave

Feeds

6455 items (6455 unread) in 32 feeds

(20 unread)

• 名师博客-华夏智慧 (20 unread)

Chinese (5202 unread)

• robbin的口水 (18 unread)
• 东京流行通讯 (77 unread)
• 思维的乐趣 (778 unread)
• InfoQ (1374 unread)
• 花钱的年华 (28 unread)
• lighty ror backup (10 unread)
• 心灵的自由 (15 unread)
• {|ihower.idv.tw| blog } (43 unread)
• 天涯海阁 (368 unread)
• 51CTO技术博客 (64 unread)
• Midnight Blog - Home (30 unread)
• David H. Hansson博客中文版 (15 unread)
• 汉语编程的BLOG (159 unread)
• Ruby新闻聚合 - Ruby中文社区 (904 unread)
• JavaEye论坛精彩帖子 (447 unread)
• 美景旅游博客 - Meijing Travel Blog (67 unread)
• 微趣 - minifun.cn (552 unread)
• 阮一峰的网络日志 (125 unread)
• Lighty RoR (30 unread)
• IceskYsl@1sters! (98 unread)

Japanese (1139 unread)

• TECHSCORE (53 unread)
• 最速インターフェース研究会 (44 unread)
• たたみラボ (24 unread)
• モバイル魂 － 携帯業界研究 (20 unread)
• 結城浩の日記 (331 unread)
• 東京流行通訊 (373 unread)
• 速聴 (13 unread)
• Kawa.net（川崎有亮） (219 unread)
• 2061:Maxオデッセイ (62 unread)

English (94 unread)

• Midnight Oil (41 unread)
• RailsOnWave (53 unread)

RailsOnWave (50 unread)

• August 20, 2008
• 23:07

  The best recipe for creating a profitable web app in a 2.0 era

   » ‎ RailsOnWave

  We, as many other startups, are keep doing ourself the same question: which is the best recipe to create a profitable web app nowadays?

  It’s a tough question. I think a good web app, something making money, has many simple characteristics. One of the best and also funny video I found on the Net, talking about this, is the speech that David Heinemeier Hansson gave to the last Start Up School 08 (watch it after having read this article)

  <object height='276' width='520'><param name='movie' value='http://www.omnisio.com/bin/Embed.swf?embedID=ctMTgsomqr3AI0adbiFy2w' /><param name='bgcolor' value='#FFFFFF' /><param name='quality' value='high' /><param name='allowscriptaccess' value='always' /><param name='allowfullscreen' value='true' /><embed bgcolor='#FFFFFF' allowfullscreen='true' src='http://www.omnisio.com/bin/Embed.swf?embedID=ctMTgsomqr3AI0adbiFy2w' type='application/x-shockwave-flash' allowscriptaccess='always' height='276' quality='high' width='520'><noembed>Share and annotate your videos with Omnisio!</noembed></embed></object>

  In short, David recipe to create a (Internet) profitable company:

  • Make a product, price it and sell it!
    It has been working in this way from time immemorial, so don’t think that the web is different. It’s not. The best way to see if you really have something groovy to sell, is make it and trying to sell it
  • Don’t try to set up 1 billion company! The odds are against you.
    He’s right, between your current income (typically below 100k a year) and 1 billion dollars, there are a wide range of acceptable revenues. One million company is definitely a good target (isn’t it?), a target you can probably manage without anyone financing you (no VC). BTW… making one million a year is not simple, definitely not easy, but it’s immensely much simpler, than try to making 1 billion a year.
  • Target: business is better than consumer.
    Convincing consumers to spend their money is not so easy, even if your application is useful and well designed. Companies, on the other side, are always looking for tools or services enabling cost cutting or easy management or knowledge management or what so ever. So try with them first.
  • Keep it simple.
    This is a mantra for all of us and Rails helps us a lot following this direction. It’s fundamental that people could understand quickly why they need you.

  I’d like to integrate David recipe with some small ingredients of mine:

  • Your product must have a barrier to the entrance.
    I don’t know if this is the right term in English, but I mean you must avoid that someone can copy you in a fraction of a second. The elements part of your barrier can be many: good design, idea, time to market, technology, smartness (why not?), etc. And there’s a postulate to this theorem…
  • (postulate) Whatever your barrier is, remember that it won’t last forever.
    Feed your idea day by day.
  • The fact that you caught a good product once, it doesn’t mean you are like Mida king.
    Every time is a new challenge; no one will buy your product because of your once famous hit.
  • Making a good product is an art.
    It requires time and patience. If you don’t earn 50,000 dollars the first day you’re out, don’t be too angry. Pace yourself and wait. In the meantime think about how to improve it.
  • Ask yourself: would I spend 50 bucks a month to buy my product?
    It’s better to ask you this question before start coding. In any case, it’s important to repeat it every time your expectations are above your results. BTW, if you are not using what you’ve built, then probably it’s not so useful, aren’t you?
    Don’t be so sever with you. Even Evan William who built Blogger.com forgot this truth when he founded Odeo. Then he understood and created Twitter

  
• August 16, 2008
• 2:16

  Use MacVim and rails.vim plugin to edit your Rails work

   » ‎ RailsOnWave

  MacVim is the best editor ever to work with Ruby and Ruby on Rails code.

  A couple of years ago I bought a copy of TextMate, the preferred and “exclusive” text editor of Ruby on Rails community. Two years ago I was a newcomer to Ruby language and Rails framework and TextMate helped me to enter quickly in this marvelous world. Coming back to then I chose this editor because on Rails official web site there weren’t others good suggested tools.

  NOTE THIS: actually checking on the site, a few things are really changed. I read, “The entire Rails core team is using TextMate on Mac OS X. It’s a fantastic editor that ships with Ruby on Rails highlighting and macros”. I know it’s not true (Jeremy Kemper must is actually using a different tool).... is it some kind of hidden advertising?

  In any case the Macromates product is definitely a good one, but soon I felt I needed something different, something I could suggest to my colleagues, to my friends, without force them to invest 30 bucks or so. I needed something like vi... vi?

  Now vi has been replaced by vim.
  VIM (an improved version of vi) is already installed on OSX or on Ubuntu and it’s free. But to be used as my preferred Ruby and Rails text editor I needed it could manage 2 things:

  • some sort of integration with Rails (how?)
  • syntax coloring TextMate-like (yeah, I like it)

  No problem: the first issue has been trivial. You need to download rails.vim and extract the zip file to ~/.vim directory. This completes the installation :)

  For the second issue wanted to have IR_Black theme (the theme I’m using under TextMate) on VIM too. This is how it looks like under TextMate:

  

  ... and you know what? It actually exists for VIM. Todd Werth, the creator of IR_Black theme for TextMate made it available for the Unix text editor. So I downloaded and put it under ~/.vim/colors directory, I launched vim and…

  

  ... this screen showed. From the shell, in the xterm, you have access to 16 ANSI colors only, so forget the full color result. I didn’t know that.

  So? No fancy colors under VIM?

  The solution is to download MacVim a project under the Google Code site, that easily access all the colors, using all the previous settings already stored under your ”.vim” directory.
  The final result is awesome:

  

  
• August 01, 2008
• 21:43

  Fork with spawn

   » ‎ RailsOnWave

  During the development of our current project we needed to handle a very long task (4 minutes). After a bit of googling i found spawn by Tom Anderson. Here’s how it works:

  Spawn let you fork (or thread) a block of code by simply pass it as a parameter to a ‘spawn’ function:

  
    spawn do
     # very long long task
    end
  
  

  what spawn do (when used with ‘fork’) is recreate an ActiveRecord Connection inside a fork method and then execute your block of code. You can also set the priority of the process being create with the option ‘nice’:

  
    spawn(:nice => 7) do
      # do something
    end
  
  

  Finally you can wait the end or your child processes with the method Spawn::wait() (I took this example from the official readme):

  
    N.times do |i|
      # spawn N blocks of code
      spawn_ids[i] = spawn do
        something(i)
      end
    end
    # wait for all N blocks of code to finish running
    wait(spawn_ids)
  
  

  I haven’t tried to use spawn with threads but as far as I’ve tested it with fork, it works perfectly.

  
• July 26, 2008
• 1:01

  Anagrams with Ruby

   » ‎ RailsOnWave

  In my spare time I enjoy myself trying to figure out solutions to well-known problems without searching the web nor using third party libraries. It’s just a sort of challenge to keep my coding skills well trained.

  Yesterday I challenged myself trying to find the faster way to get all the combination of the letters of a given word (excluding duplicates).

  
  example:  "ruby" --> 
  ["ruby", "ruyb", "rbuy", "rbyu", "ryub", "rybu", "urby", "uryb", "ubry", "ubyr", "uyrb", "uybr", "bruy", "bryu", "bury", "buyr", "byru", "byur", "yrub", "yrbu", "yurb", "yubr", "ybru", "ybur"]   
  
  

  My code uses recursion to accomplish the task and is not able to identify at run time duplicates so it’s really far from perfection. I’m going to post it here:

  
  class String
    def anagram
      chars_size = (chars = self.split('')).size
      return chars if chars_size == 1
      return [chars,chars.reverse] if chars_size == 2
      ret = []; chars.each do |c| 
        (temp = chars.clone).delete_at(chars.index(c));
        ret += temp.to_s.anagram.collect{|a| "#{c}#{a}" } 
      end    
      return ret.uniq
    end
  end
  
  

  If you want to share a better solution please use the comment form below to link your code (you can use Pastie) or just to suggest changes.

  Sandro

  
• July 05, 2008
• 1:43

  A new CheckBox component in Streamlined

   » ‎ RailsOnWave

  I’ve noticed that Streamlined when display has_and_belongs_to_many or has_many relationships in an edit view calls ‘Streamlined::Components::Select’ (lib/streamlined/column/association.rb line 123). That class simply render a ‘select’ tag with multiple choices.

  I created a new component that can be called instead the standard one. It’s called CheckBox and it displays, as the name may suggest, a checkbox for each choice available.

  To add this component simply create a new file under ‘lib/streamlined/components’ called ‘checkbox.rb’ and paste the same content of ‘select.rb’ except these two changes:

  
      # line 15
      class CheckBox
      REQUIRED_ATTRS = [:view, :object, :method, :choices, :item]
  
      # Substitute the render method with this 
      def render
        ids = item.send(Inflector.pluralize(method.to_s)).collect{|b| b.id}
        name = "#{object}[#{method}][]" 
        choices.collect do |c| 
          view.check_box_tag(name,c[1],ids.include?(c[1])) + "#{c[0]}" 
        end.join("<br/>") + view.hidden_field_tag(name, STREAMLINED_SELECT_NONE)
     end
  
  

  Remeber also to include this new file (from lib/streamlined/components.rb) and change the line 123 in association.rb to call this new component:

  
        result = Streamlined::Components::CheckBox.render do |s|
          s.view = view
          s.object = model_underscore
          s.method = name
          s.choices = choices
          s.options = {:selected => selected_choices }
          s.html_options = {:size => 5, :multiple => true}
          s.item = item
        end
  
  

  Sandro

  
• July 01, 2008
• 17:30

  Ruby on Rails & Maths...

   » ‎ RailsOnWave

  I have always been fascinated with Mathematics and how you can solve problems using it, we all know that in programming it is very useful. I recently had to use maths in a layout that I needed to incorporate for a new application…

  Problem:

  I had to display a dynamic list of suburbs in a table, that was an x amount of rows and had 3 columns.

  Solution:

  I used Mod (the mathematical arithmetic that gives you the remainder of the division).

  Therefore:

  
  <table>
  <% r = 0 %>
  <% @count_suburb.each do |c| %>
  <% area = Area.find_by_code(c[0])%>
  
  <% if ((r % 3) == 0)  %>
  <tr>
  <% end %>
  <% r += 1%>
  
  <td>Write something here....<%= c.name.capitalize  %></td>
  
  <% if ((r % 3) == 0)  %>
  </tr>    
  <% end %>
  
  <% end %>
  </table>
  
  

  Does anyone know of a better solution?

  Thanks Annalisa

  
• June 27, 2008
• 18:06

  Advanced statements with Ruby

   » ‎ RailsOnWave

  Yesterday I was playing with statements trying to find out an elegant way to solve a problem:

  The problem

  While reading from an Excel file (using the Parseexcel gem) I needed to get a value from the 3rd column or from the 2nd (if the third is empty). Plus I had to execute an additional operation only if the value I got came from the second column. ( value / 100 )

  

  The Solution

  Parseexcel lets you scan your Excel worksheet by rows. Each row makes its value available through the ‘at(pos)’ method where pos is the index of the column (starting from 0). This is the solution I come across:

  
  worksheet.each(3) do |row| 
          break if ((value=row.at(2)).nil? and (div=true;value=row.at(1)).nil?)
          value = value.to_i / 100 if div
          # other code ...
  end
  
  

  Conclusion

  By using this trick I was able to detect when the assignment come from the second or the third column (remember that when the first condition in an ‘and’ clause isn’t met the interpreter doesn’t execute the second, thus div remains nil if row.at(2) is not nil).

  Hope this could help. Sandro

  
• June 20, 2008
• 22:09

  Streamlined 1.0 hacks: add help text to forms.

   » ‎ RailsOnWave

  I’ve created a small Streamlined hack that let you implement a :help option while defining ‘user columns’, here’s a sample:

  
                  :title,                 {
                                            :human_name   => "Book title",
                                            :help         => "Please specify the title of the book you're reading." 
                                          }
  
  

  and this is the result (for ‘edit’ and ‘new’ views):

  

  Instructions:

  Here you’ll find what to change in the plugin:

  
  #  in /lib/streamlined/column/base.rb 
  
  # around line 9
  attr_accessor :human_name, :link_to, :popup, :parent_model, :wrapper, :additional_column_pairs,
                  :additional_includes, :filter_column, :help
  
  # around line 196
        x.td(:class => 'sl_edit_value') do
          x << render_td(view, item)
          if(!help.nil?)
            x.p{ x << help }
          end  
        end 
  
  

  Hope you’ll find useful.

  Sandro

  
• June 11, 2008
• 21:53

  A free book about Rails 2.1

   » ‎ RailsOnWave

  “A gift from all Brazilian Railers to the international community”.

  This is how Carlos Brando presented the release of a free book about Ruby on Rails 2.1 that he and Marcos Tapajós just released on the Internet.

  The book has been translated from Portuguese thanks to the aim of the Brazilian Rails community in general, and in particular with the effort of Rafael Barbosa, Caike Souza, Pedro Pimentel, Abraão Coelho and Ricardo S Yasuda.

  Thanks guys.

  
• 8:21

  Is DHH planning to step back?

   » ‎ RailsOnWave

  I’ve been to Portland to the RailsConf 2008 and everything has been quite great. Great venue, a lot of people and good food too – and that was really a surprise :)

  There’s only one thing that left me a bit confused: “David Heinemeier Hansson”. I mean, he’s a great speaker and hacker too, but this year he didn’t make any technical speeches at the conference. He left that role to Jeremy Kemper, who is for sure a wizard inside the Ruby on Rails community, but… he’s not David of course.

  David has a unique role in the Rails community, and right now the Rails future and success is definitely tied to him. The community needs a leader and a mentor, and David is the man.

  But what will happen if he stops having a technical leading role in Ruby on Rails?
  That could really be a bad strike for all of us. The framework is too young and it’s still gaining a dominant position in the technology landscape. It needs its creator more than ever.

  A second “bad” sign I picked up on was during the final speech, with all the Rails core team on stage, David did not seem to be completely up-to-date with the actual status of Rails – and Michael Koziarski had to correct him once.

  That was not a good thing. Definitely not a good thing.
  In the end, just to give us the final shot, he decided that “it could be a good idea” to leave the conference 15 minutes earlier to catch the flight :)

  What’s up man?
  Does it mean something is changing?
  Is he planning to step back from his role?
  I hope not, because in that case Ruby on Rails could be threatened very quickly by its competitors, risking to lose its rising star role in the technology landscape.

  So David, please stop evangelizing and show us the light. We need you to make some code.

  
• June 10, 2008
• 5:23

  Spread out the good novel

   » ‎ RailsOnWave

  RailsConf is over and I was so lucky to be there this year too. GotThingsDone.com presence at the all-important convention about Ruby on Rails has been centered around spreading the good novel” out all over the world. Let me explain you why.

  We were pretty impressed last year discovering that quite a few people were covering the event professionally with videos, interviews and keynotes streaming. The most part of the attendees having a blog were summarizing the convention in real time on their web sites and they did a good job, but I soon realized people want to see their heroes, want to hear their voices. Dancan made amazing pictures and he shared them on Flickr, but you know, they cannot speak.

  So, this year we decided that Rails is too important to not have any good video interview to show the people who were not as lucky as we were. We wanted to show what a revolution was taking place in Portland.

  So, in the last few days preceding the conference the crew at GotThingsDone.com and I planned to interview some of the people we thought are leading the Rails scenario right now. We aren’t professional in producing videos, but we made our best to share the intense moments we had there.

  So I’d like to say thank you to the people we interviewed, because they were so patient and kind with us. Thanks to David Heinemeier Hansson, Joel Splosky, Jeremy Kemper, Ola Bini, John Straw, Ryan Singer, Rick Olson, Chris Wanstrath and Geoffrey Grosenbach.

  And then thank you to Annalisa, Sandro and Joe for their wonderful job.

  At Portland we were about 1,800 people. Right now our interviews have been viewed more than 7,300 times :)

  
• June 09, 2008
• 16:18

  RailsConf 2008 Keynotes now available...

   » ‎ RailsOnWave
  David Heinemeier Hansson, Jeremy Kemper, Kent Beck and Joel Spolsky.

  If you missed out on the RailsConf 2008 this year or you would just like to have a recap on the Keynotes, you can now view them here.

  If you have not yet seen the interviews of DHH, Jeremy Kemper and many more…. please view them here.

  Annalisa

  
• June 06, 2008
• 0:41

  Now available: Interviews for your iPhone/iPod

   » ‎ RailsOnWave

  As we promised here are the links to download the interviews and view them on your iPhone or your iPod.

  David Heinemeier Hannson
  Ryan Singer
  Jeremy Kemper
  Rick Olsen
  Ola Bini
  Geoffrey Grosenbach
  Chris Wanstrath
  Joel Spolsky
  John Straw

  
• June 05, 2008
• 22:44

  Interviews soon available on iPhone/iPhod...

   » ‎ RailsOnWave

  Stay tuned, we are currently working on the interviews to make them available for you in iPhone and iPod format.

  They will be published in the next few hours….

  
• 17:14

  Adam Pisoni: Skynet - A Ruby Map/Reduce Framework

   » ‎ RailsOnWave
  Pisoni illustrates Skynet, a Ruby framework to develop applications with regards to the Map/Reduce model.

  Map/Reduce is a programming model aimed at the developing of distributed applications that automatically manage the major parts of the problems of distributing computing; map/reduce enables you to create parallel applications.

  Skynet is a framework for the distributed computing on Ruby (like MapReduce) with some differences: Map/Reduce uses two types of processes, masters and workers. Skynet only has workers (the role of of the master is that to assign activities divided into tasks.

  But without masters how can we divide the work into tasks? Each worker becomes a master for a particular job, and takes on the responsibility to divide the work into tasks and assign them.

  Each worker observes the others in a way to understand if a task fails. When a task is taken up, it is automatically “copied” in the future, if the worker finishes the task it also cancels the future copied task otherwise it is left for someone else to pick it up.

  How does Skynet follow your code?

  
  mapreduce (users) do |u|
        codice
  end
  
  

  To use Skynet you need to use the following command:

  
  skynet_start
  
  

  (note: you need to restart skynet each time you change the code)

  Skynet & Rails

  Skynet can be used in conjunction with Rails for the following tasks:

  • send an e-mail
  • to execute a migration

  Annalisa

  
• 0:56

  Lightening Tasks

   » ‎ RailsOnWave
  With Lightning Tasks it intends all the presentations that are non foreseen in the program to those that are granted a very limited space (10 minutes). Some followed projects/interesting ideas come out during these micro sessions: Saturday 31 May 2008

  Between the most interesting sessions in this day RAD is surely mentioned, a framework that allows you to use Ruby to Arduino

  The guys from FozWorks have presented and preview of a patch for Sphinx that makes it possible to search based on the geographical distance between the two or more objects.

  In conclusion it was very appreciated also the intervention of Josh Goebel the creator of the famous Pastie that entertained the audience speaking about the advanced functionality of the application, like integrating with textmate, vim and the Pastie bot for IRC.

  Sunday 1 June 2008

  From the proposals of the sessions of Sunday, the following must be mentioned:

  MethodTrails

  It is an application for Ruby 1.9, visualized and printed in a graph all the internal relationships of a Rails application (the relations between the various methods).

  Plugin: RESTFUL workflow A plugin to create a workflow similar to that of an interview that allows you to create a wizard of n-pages with saving the data at the end. The workflow is defined from a DSL.

  Dave Woodward

  He presented a REST interface through that a Rails application can have a dialogue with Jabber.

  Last but not least, an expected RSpec Story Runner bundle with Textmate was presented (personally).

  Annalisa

  
• June 04, 2008
• 23:44

  Obie Fernandez: Ruby coding best practices

   » ‎ RailsOnWave
  Through examples e fragments of code Obie show the practices to avoid when developing in Rails.

  Obie: You need to know the basis of ruby before you can declare yourself a Rails developer. David Black has published a book for those who would like to learn ruby knowing only Rails.

  Those who do not know Ruby can construct a very complicated construction when you could use ‘shortcut’ offered by Ruby; we don’t reinvent things that Ruby has already created and optimized. (for example there exists a function include? to control if an element is in an array without creating a cycle).

  It is important to use the routes and the dynamic associations

  On the screen appeared a method that before carries out a query on all the photos to choose a random id and retrieve with another query that photo, clearly not a good programming example.

  At times the laziness easily takes the programmer to make various errors.

  It is important to use various methods that follow simple actions, not to create methods that make many diverse things!

  The speaker in front now ironically defines some errors “Premature DeOptimization” that are centered on generating code that decreases the execution of the application, also to generate actions directly in the ApplicationController is not a good idea.

  Abuse of the database, happens when we use without too much reflection the functionality of ActiveRecord (like for example we use with light association dynamically inside the cycle).

  Also to use the cache in a way that is wrong and dangerous. You don’t cache anymore putting the data inside the global constants/variables in how much it finishes all the RAM.

  Don’t create controllers that are too long.

  On the screen appeared a long action (about a hundred lines) that at the end of the process has ‘return true’, applauding and laughs came from the room. It is important that you encapsulate all the logic of the business in the models following the thin controller principle, fat models.

  We must also be careful to maintain the code created always readable, not to be tempted to “compress” the code too much.

  The RESTful architecture must be used correctly (on the screen compiles a controller attached to a shopping site with various procedures, that are for nothing RESTful)

  We need to always try to use diverse plugins that make the same thing to understand which is the most functional and performance the best.

  When the HTML helper degenerates: on the screen appeared a helper to generate a frame and inside a photo, the helper is hundreds of rows long and the speaker shows how difficult it is to maintain a function of this type. In this case what does it verify, says the speaker, it is good to know that it is needed to generate a new level of extraction to manage the problem (for example to create a ad-hoc model).

  We create a methods with constant names, that are most possibly self explanatory (on the screen appears a method that is called finderer that returns a set of options for a method find, difficult to extrapolate without reading the comments).

  We cancel the commented code, in any case we use SVN or GIT that keeps track of these things….

  On the screen appears the UsersController, an complete application all in a controller, the curse of best practice, applauding and laughs came from the audience.

  Conclusions

  • learn the fundamentals (of Ruby, of Rails) Rails is not a magic language that makes programmers those who don’t know, it is faster to establish on the conventions but it is necessary to know how to use them!
  • learn to learn from people that know more than us, if it is maybe possible to program together with people (pair programming). (the best would, says Obie would be to take SmallTalk programmers with years of experience)
  • Read books about the subject.

  Annalisa

  
• 21:54

  YellowPages.com migrates to Rails

   » ‎ RailsOnWave
  Yes it’s complete from the intervention of John Straw, Chief Software Architect or YellowPages.com. It was very enlightening and useful. These people can boast with numbers with all respect and they are the second biggest case study on the Ruby on Rails front: 23 million visitors a month. They have just recently migrated to Rails and it has been a success. From 125.000 lines of code in Java, mainly written by external consultants from 2004 to 2005, to at least 20.000 lines of code in only 3 months of development from a team of 4 developers. The previous version of code of the Yellow Pages was suffering from diverse problems, such as:

  1. difficult maintaining
  2. difficult to extend
  3. not well adapted to SEO activity

  The new version responds to all these interrogations and many others. The new architecture is based on 90% Rails and the structure appeared like this:

  

  The choice of Rails was reached from results of diverse evaluations that they did involving also the architecture EJB3/Java e Python/Djongo. At the end the management has decided to bet on Rails, considered as the best solution to the problem. When it was realized using Capistrano for the delivery phase e 25 machines in the production environment.

  

  But the question that everyone that is attending this intervention is asking was: ... and the performance? 23 Million visitors a month is a big challenge for every operating environment, the goals that Yellow Pages had were:

  

  ... but not all of them were easy and immediate, but at the moment of the launch all them demonstrated totally acceptable:

  

  In conclusion … a great success:

  

  
• 21:30

  David Chelimsky: Integration Testing With Rspec's Story Runner

   » ‎ RailsOnWave
  Most of you know RSpec’s, the Rails plugin used for generating Unit test intuitive and elegant, with Story Runner RSpec it makes its entrance triumphant in the world of Integration Test. Introduction:

  This is a tool that integrates with BDD (Behaviour-driven-development), which is programming describing what the program expects from us. Dan North wrote JBehave, which inspired Story Runner. the BDD take part of the second generation development of agile technology.

  RSpec started from a post from Dan Astels and is programmed from Steven Baker. It has started two years ago and is passed to David Chelimsky.

  The principle that it is based on is the Feature Injection (Christ Matts): extracting the story from the functionality of the application and dividing this story in the background.

  How do they create this story? Using the methodology of why? Here is an example; let suppose that we want to create a Rails application that manages the registration of people to the RailsConf and we apply to this the why methodology process:

  “I want the people to register” why? “I want to measure the influence at the conference.”

  At this point it is necessary to create a story that describes in some way the extend of the second affirmation.

  Some Definitions:

  Integration Testing: Make it in a way that the components function well together (in reality David confirms that the are many diverse definitions of Integration Testing but this is the one that is accepted from the Rails Community)

  BDD: Before the code exists: Write what you expect from the code when the code is written: checking that the expectations are respected.

  RSpec StoryTelling:

  RSpec Story Telling is in essence a way of describing the story that tells a particular flow on the inside of our application. similar stories are mapped through DSL to the blocks of code. Following similar blocks you can determine if the application is more or less coherent with the story described.

  Here is an example:

  
  Story: Project
  
      As a user 
      I want to create projects
      In order to start planning
  
      Scenario: Create the first project as Account Admin
  
          Given demo_account_admin as current_user with password xxx
          And with all the projects archived
          When click on /accountadmin/projects/new
          And choose the project context
          And set name as 'My first test project'
          And set vision as 'The magnificent creation of RSpec'
          And post to /accountadmin/projects
          Then flash must contain 'Project successfully created' as info
  
  
  

  Each story is formated with: title, summary, and many scenarios that did not merit functionally but must follow a predefined structure (what is the objective? who is using the system? What is the action?

  The scenario can use the following verbs: Give, When, Then that describe the initial conditions, actions and final conditions (anticipated).

  The phrases formatted in the scenarios with these 3 verbs are then “linked” to blocks of code, some of the phrases can be imagined in a variable.

  Some possible implementations:

  Rails StoryTelling gives the possibility to access all the methods of Rails to all the methods of RSpec.

  Webrat (Bryan Helmkamp), serves to manipulate the dom simulating the server-side navigation on the inside of the page.

  In place of the Webrat you can use Selenium-RC, this option has its advantages (javascript support) and from confidence to the clients but pays its price in terms of slowness.

  Annalisa

  
• June 03, 2008
• 1:18

  Neal Ford: Design Patterns in Ruby

   » ‎ RailsOnWave
  The room is crowded, on the screen appears the book “Design Patterns (the gang of four)’, in this book, Neal says that there are not only references but also valid examples (even if they are not expressed in Ruby)

  There are two destinct problems Neal confirms, the patterns in theor theoretical exceptions and their implementation. The dynamic languages have a big advantage when it means impementing patterns in real cases.

  Iterator Pattern:

  Neal does not appreciate this pattern very much: little tecnical for the technical people and too technical for the non technical people. The pattern provides the ability to access in sequence an array of elements.

  Neal asks: what do we need these patterns for compared to a normal iterator .each? in reality even an iterator each apply to a iterator pattern (internal).

  Instead the external iterator is a version of this pattern implemented, for example in the cycle for.

  Command Patterns:

  The command pattern is implemented in Ruby through the blocks. Each block incapsulates a command. In reality this comparison is not 100% true, it will need some modifications to be made to tie in the command pattern to a block.

  Strategy Pattern:

  This pattern defines a set of algorithms, incapsulates them and makes them interchangeable. It is implemented in traditional ruby with a module that defines an empty function that is overwritten one at a time form the classes that it includes it.

  But what will happen if the method in question is maybe “call” (the combination between the strategy and the command pattern)? Each algorithm will be incapsulated in a block and the array of this block shall be implemented from the strategy pattern.

  Another possible implementation: to make it in a way that a class extends another dynamically. (choosing which classes should extend instances in question in a way assigned like this methods are diverse to the classes)

  Interpreter Pattern:

  Supply an interpreter to grammer to interpret a specific language. (JRuby for example is an example of the application in this pattern) With this pattern it is possible to construct DSL (domain specific languages). With Ruby it is very easy to construct DSL in virtue from its flexible syntax.

  Adapter Pattern:

  Convert an interface into another. The implementation standards in ruby, gives you two classes (round and square), to create a third that in some way transforms the instance of the object of the class A into an object of the class B.

  We can dynamically create methods of instances for the instance that we want to modify. But what will happen if in this way we create a conflict of methods? We can dynamically modify the names of the methods to make it in a way that they don’t overwrite the event, then creating a kind of selector to specify each time which method we want to call between those that are available.

  Sate Pattern:

  Changing the class of the instance to take place a particular event. To implement this pattern we can utilize mixology, a gem that consents us to perform a mixing of modules.

  Null Object Pattern:

  Utilize an object that impersonates the Null concept. This pattern doesn’t exist in Ruby. It exists directly in the class language that is called NilClass.

  Aridifier Pattern:

  It is a pattern that is derived from the book “Programmatic Programmers” that aims to make the language more arid, in how much according to the author a language is more arid is for its nature more secure.

  Conclusioni:

  Neal concludes stating that Patterns are not anything but solutions valid for a common problem.

  Annalisa

  
• June 02, 2008
• 6:20

  Ryan Singer: UI design on Rails

   » ‎ RailsOnWave
  How to break down the wall that has always divided developers and designers? Ryan Singer has the solution.

  There exists a wall between the design and the development, in reality this is false perception deriving from the wrong assumption that the designer must create the graphics for an application. The designer must have a profound understanding of the product and can in theory shape and describe it.

  The process that Ryan foresees is that the designer can, actually must operate at modifying the structure and the functionality of the application. The designer must also have the base knowledge of code that the application has been written in.

  To give the designer other than the knowledge that he needs, an incremental learning approach, from this point of view the discussion simplifies in how much the designer in reality already know very simple programming languages (HTML, CSS…) from that they can derive the base concept of which is needed.

  The first step is to have the understanding of the views, then the controllers and in the end the models (but this is not essential for the work of a designer).

  If they can get to this level of mutual understanding it opens up another channel where the designer and the developer can communicate. In an ideal vision the designer is responsible for the views while the developer concentrates on the models and the controllers.

  Ryan is know presenting a fraction of a controller from basecamp that he uses as an example to show the cooperation at the code level between the designer and the developer that is the only way to have satisfactory results.

  Ryan concludes explaining how the designer can benefit from some architecture utilized from the developer. Like for example REST through which it is possible to define a base schema to access a resource.

  Annalisa

  
• 5:25

  Michael Latta: Building a Composite Model in ActiveRecord

   » ‎ RailsOnWave
  Michael that talks about his experience in creating models that inherit from an emulation of ActiveRecord.

  It could be an interesting session. Michael uses ActiveScaffold to create an application for a demo, the difference is that he does not use use ActiveRecord to managge the models ma emulates ActiveRecord with a ad-hoc class that he virtualizes.

  The approach utilises to implement similar classes is to “find a bug and solve it” repetitively, that in Michael’s opinion is like making a TDD (test driven development)

  Clearly emulating ActiveRecord is complicated, for example to recreate the update function, manage the association and keep the functionality of extensions and macros.

  (the discussion now moves towards technical detail necessary to perform this)

  Also to support the counting was not an easy task Michael confirms (just as the find method).

  Once the VirtualModel is compatible with ActiveScaffold you need to make it in a way that this accepts the creation of a new instance, also here the use of the procedure is the same; continuously finding errors and fixing them.

  I find the idea that is shown by Michael also not his own (at least from my point of view), no practical value has he been able to be show in detail of a library such as ActiveRecord.

  Annalisa

  
• 3:32

  DHH: The great surplus

   » ‎ RailsOnWave
  David Heinemeier Hannson’s Keynote talking about the great surplus that Rails has above other mainstream languages

  He says that Ruby on rails is still a tiny community but we already have this surplus above mainstream languages.

  Why do we have this surplus? What is the surplus and how can we maintain it?

  DHH says that there is still something missing from mainstream languages that gives Rails this surplus above them.

  Mentioning Joel Spolsky that touched on it this, what makes rails a blue chip above other mainstream languages. RoR is not a unique environment to have these characteristics, for example if it also had Smalltalk, Lisp but these miss something to make it more economical.

  How did rails get the surplus??

  Rails is continuing to grow and new people are interested and joining the community. We have grown in the last 5 years in the Rails environment

  Developers that believe that they are special, it becomes a negative point.

  He also says that there are so many different industries in RoR, and even in the same industries things are never the same in web applications. Programmers are not so unique, we all have something in common.

  We ceded flexibility?

  “People like choices better than having to choose.” We like having the choice but when we come down to choosing. In the rails community we don’t like having to choose but we want to have the choices to choose from. We don’t want 50 plugins to choose from but we want one that is in the framework.

  From this the convention over configuration is derived; we don’t want to have to choose every time inside the configuration of my webapp.

  DHH says that programmers thought flexibility is what we wanted but actually we like having preferences/default choices. From this derives the existence of:

  1. ERb like template language base
  2. ActiveRecord like ORM
  3. Prototype like the JS Framework

  These are not unique alternatives but default choices but it is great to give the programmer the opportunity to choose, they show that they care and that we as programmers decide what matters in technology

  With RoR you get more things done than in the mainstream environment. He quotes the statement that “Great people rarely fail because of poor technology” and comments great people can do more than not fail, they can do great too.

  Another reason why Rails has a surplus is because he feels that we care about ourselves. He also says that “Ruby is designed to make programmers happy” : which is an awesome saying to sum up programmers. We have momentum, we have a lot pushing for us. But he says that there is some bad news.

  Bad News The bad news is that the surplus won’t last forver. the surplus is limited. He points out that one of the following can happen:

  1. mainstream copies rails: but that is highly unlikely (java being able to do scaffolding)
  2. dramatic alternative arrives, a new approach. just as rails got rolling with more than 5% advantage over mainsteam development.
  3. Rails becomes mainstream, loosing the surplus by becoming one of the others.

  DHH adds that if everyone used rails it would be cool. Although the famous question “does it scale” he says, so what if it doesn’t he adds, does that mean that they wont switch. You want people to use bad (he actually says crappy) tools so that you have an edge over the others. We want to rescue people from bad tools.

  Therefore before our surplus reduces we need to spend it.

  It is only a job

  DHH comments that there are so many people that use the saying when quoting on their job “it’s just a job”. He continues to say that within the Rails community, this language is not only a job. It is not possible to sacrifice 1/4 of your life to something that you don’t enjoy. For him that is a sad phrase.

  How do we spend our surplus?

  He says that we need to blow the surplus at every opportunity that we have. Running at 110% at all time, pushing out features and completing the projects as soon as you can. Investing in ourselves to grow with knowledge.

  DHH says that programmers are 1:10 that outlast other people by 10 times but no-one is born a Rock star programmer, we learn as we go on.

  Investing in ourselves he doesn’t just mean programming 24/7 but he points out the following techniques that he uses in investing in himself to become better:

  1. Recharge tangentially: sitting in front of the screen all day, does not make you a better programmer, do something in your spear time. Activating parts of your brain to work like a muscle. The best programmers do something else than just program, engaging parts of the brain brings people to the next level.
  2. Sleep more: more than 5/6 hrs of sleep. It becomes a waste when you not functionalling properly. projects are not dependent on what happens in one day. Stop working full hrs, use your peak performance hours.
  3. Read paper. Keep reading books and not just technical books but also other kinds of books.

  Some books that DHH advices are:

  1. Gerarld M.Weinberg – Secrets of Consulting
  2. Kent Beck – Implementation pattens

  DHH points out a few important point for us programmers which are:

  • that we must move more towards understanding the business (to its concept) and design, we must have the capacity to understand what we are working on is valuable or not. We must program less but program the right stuff.
  • at times start from scratch, you learn more when you start a new project as you can apply what you learnt from your previous project.
  • share your code, participate in blogs and talks. Sharing is not about other people, you get more out of it from spreading the message.

  Concluding this he quotes this phrase: “The purpose of playing this game well is to be able to get the best position on the next game.”

  DHH tells us about a new concept that 37signals have introduces: a 4 day work week, people ask “how can u afford it?”, “how can you program in 4 days”. He points out that it is only 20% less, which is not much change in productivity and that actually production has gone up. He says that working as many hours as possible is irrelevant, the amount of time put in is a weak colloration from the amount of time that comes out.

  He confirms that his new approach is working at 37Signals and he actually feels he is more productive.

  DHH concludes that the surplus will not last forever therefore invest in yourself and become better programmers.

  Annalisa

  
• May 31, 2008
• 17:13

  Hosting and the Woes

   » ‎ RailsOnWave
  Ezra Zygmuntowicz, Jamie van Dyke e Tom Mornini talk about the difficulty intersected in hosting a rails application

  I am sitting at a round table amongst the participants are part of Engineyard, the live motif of the session and clear hosting, how to create a good system for hosting RoR?

  The session will include a few problems that are linked to the world of hosting Rails;

  ActiveRecods

  ActiveRecord is fantastic in terms of functionality, but a a pest in presentation, to this it is added that in the major part of the cases it is forgotten to utilize the indexing of the database. Other than the indexing specifying in order the wrong useless results during the joins. (a good strategy to remedy the problem and use the statement SQL EXPLAIN)

  Sphinx is a good solution to reduce the index dimension, much better performance than Ferret.

  Image Science

  EngineYard uses Monit to monitor the service but this becomes a problem with the various environments, but they say that the problem has been easily resolved.

  Hodel 3000

  This product modifies the format of logs of Rails, its only problem is that, if you do not change the settings in the configuration file, it generates a lot information on the debug.

  How to manage the traffic peaks?

  What happens if your website uploads in the homepage of Digg? The solution is to cache each page possible, but not always can you apply this solution (for example the signup procedure), in this case it is important to benefit the caching of queries.

  When do you influence the choice of the server?

  Between ebb, mongrel and thin there is not much of a difference, the quality of the product code counts more and the caching the procedure implemented.

  Annalisa

  
• 16:39

  Dan Benjamin: Entrepreneurs on Rails

   » ‎ RailsOnWave
  I have just had a few words with Dan, he is agitated and he did not expect that many people, probably this session was the most full amongst the other sessions.

  The room is (unexpectedly) crowded and Dan is about to start his session.

  A small poll on how many people in the room are freelancers: the majority. Dan Benjamin speaks about his 15 years experience in development with his software house and says that he would like to share with us how much he has learnt.

  The key of success is always the same, to find a product that satisfies a need (just like what apple did).

  Dan speaks about Jeff Bezos, who was obligated to produce the book that he wrote only because it was refused by all publishing houses, having a huge success.

  What do you need to start?

  First of all an idea, that must be clear but not static, that can change with time if it is necessary. Then you need energy to be at 100% on the idea. Dan says that you also need Spirito Guerriero, the will to go ahead and to sacrifice for the project.

  Before you start:

  You need to first know why you are doing this, especially for the projects OpenSource, that is always with more difficulty are a good starting base to make business. You need to then have the objectives that are temporarily fixed. Dan adds a very important thing: you need to from the start know in what way that which you are doing will make money. Another important thing, you need to have is an open escape street: meaning that if things go bad there must be a way to get out of the project in a pragmatic and premeditated way.

  Why create a company ?

  Dan makes it evident that a company is a separate entity, it is like a second personality, for that you must pay tax. There are also positive sides, for instance collaborating with other companies is much easier (clearly he is talking about the American system) or keep loans. Also the fact that owning your own company helps also the affair relations (a precession of security).

  Clearly owning a company costs and bureaucracy increases.

  (at the moment Dan’s conference is very interesting but very little link to Rails, some people leave the room….)

  What company to create?

  Dan is doing an overview on various types of companies that is possible to create in this country.

  And Then?

  It is essential to create a brand that can show your company. The brand must have a message (simple and concise) that describes your activity. Dan announces that it is not good to over exaggerate and make it seem that it is more than it really is. It is also important to position the brand. For this you need to have a clear idea who is the client that you are marketing for. Dan confirms that the first few months the marketing is much more important than the programming.

  Making it work

  The most difficult challenge is linked to the managing the flow of requests from the clients; it is difficult but you must be able to say no if the requests become too much or risks reducing the quality of the product. It is also important to remember that working from home for long periods seems to make people less productive and reliable, it would be better to have an office and to be at least in two.

  (interesting interval: the security guards are clearing the room as it over the limit)

  In our environment, Dan proceeds, it is very important to write analysis quotes to the clients that are the most possibly detailed (affirms that the documents that your company produces are never less than 40/50 pages) Dn continues saying that you never need to start code without a contract.

  The discussion concludes on a good note to invest the profit earned, legal consulting and publicity is in Dan’s opinion the two most important sectors in which you need to invest.

  Annalisa

  
• 5:32

  Joel Spolsky's keynote

   » ‎ RailsOnWave
  Joel Spolsky, Author of the blog JoelOnSoftware, has been given the opportunity to inaugurate the session of the RailsConf2008.

  After a discussion starting with Chad Fowler (very much an introduction – where is David Black?) and a few words from DHH, to the stage he presents Joel Spolsky.

  The theme of the keynote is UTC-based migrations in Rails 2.1, on the screen appears an image of Angelina Jolie and for contradiction, Brad Pitt.

  He asks us why Brad Pitt is so popular, with comparison to the iPod, why is it so popular?

  Entering in the software theme, Joel confirms that good software makes people happier, it is obsessive in the terms of esthetics and with respect to the culture code to that which is written.

  Now Joel Spolsky is simulating a windows XP session that just has he has access asks to restart the system to complete the updates, clearly a bad example in software.

  A similar example when entering a new device windows XP asks for the installation CD that could be lost and difficult to find.

  Lets talk about helplessness, meaning the capacity of some depressing software, a depressing situation deriving from perception that no-one helps you.

  Joel now presents two websites, one wizard like and one with all the information written on one page; this is the rule of a good design, to do it a way that the user has feedback of all the operations that follows.

  Ajax is great to use as it reduces the reaction speed between the click and the feedback, this is the way to make the user happier!

  Obsessive over esthetic: on the screen appears the iPhone and the Samsung Blackjack, seems in technical terms the blackjack to perform better and it is cheaper. Why is the iPhone preferred between the two? Because it looks good!

  Another example: On the screen appears two beautiful buildings in Paris, but without the emergency exit (like those that you find in NYC). The stairs were not added because they would have ruined the beautiful look of the building.

  Clearly Joel shows that the esthetic concept is very subjective, but some values do exist, for example the skins of an application is not a wise choice.

  There exists a architectural movement that eliminates the decoration, for Joel it does not seem at all a good idea, an modern operating system that becomes command code without decoration.

  Observe culture code: on the screen appears to vehicles, one Jeep and a normal vehicle, the jeep can give you a sense of security, but more people die in Jeeps per year than in other cars. Therefore the perception of security counts more than security itself.

  Now he turns to a few words on Web 2.0 also this concept is abstract, but underlined an idea that opposes that with respect to the enterprises.

  On the screen appears ‘Ruby’. Joel invites DHH to read a piece of writing on RoR, from the piece of writing he takes a few keywords beauty – happiness – motivation – pride – pleasure – passion, that forms the perception of this language. For other languages the keywords are worse. These words represent the culture code.

  Misattribution: a psychologic definition that explains why sometimes our bodies reacts to particular psychological stimulations.

  In this case, Joel Spolsky explains that it was put on us when he prepared the keynote, reading the introduction title, that it was false!

  Annalisa

  
• 1:12

  RailsConf 2008 is on air!

   » ‎ RailsOnWave

  The most wonderful conference about Ruby On Rails is starting and GotThingsDone.com is again Gold Sponsor. This year we have big news about our main product: WhoDoes 2.0
  

  

  Chad Fowler is introducing the whole program right now. Keep following us on this blog or at Wave Factory blog

  
• May 06, 2008
• 15:00

  WhoDoes 2.0 amazing groupware features

   » ‎ RailsOnWave

  WhoDoes 2.0 is almost ready to go, but in the meantime I’d like to show you one of most interesting features we have introduced with this wonderful new version: groupware.

  Now you can let other people look for you inside the WhoDoes user’s directory and allow them to make you part of their team. This is actually a real innovative feature in project management tools where you can now staff your team in seconds.

  To enable other people to find you easily, you’ll have to check your settings inside the Settings tab of WhoDoes 2.0:

  

  You can easily decide to keep your identity hidden or simply let people that share your email domain find and staff you automatically or set it that all users using WhoDoes invite you inside their projects.

  
• May 05, 2008
• 20:24

  Your task list in WhoDoes 2.0

   » ‎ RailsOnWave

  As you probably already know, we will release a completely renewed version of our project management tool in a few days. It’s named WhoDoes 2.0 and could dramatically make project organization easier in your company, in your team or simply in your daily life.

  One of the new features WhoDoes 2.0 introduces is the ability to group all the tasks in a project by team member, independently from the milestones through which the tasks are bound together.

  It’s easier to understand how useful it is, by observing this screenshot:

  

  Stay tuned to learn more about this revolutionary tool.

  
• April 30, 2008
• 22:33

  Tasking with WhoDoes 2.0

   » ‎ RailsOnWave

  Tasking items has never been so easy and simple with WhoDoes 2.0

  <center> </center> How it is done…

  The Task List gives you a clear indication of the workload for each team member, all tasks assigned to team members appear below their names and closed tasks are shown with the number of tasks that are closed.

  WhoDoes 2.0 has taken working on paper and implementing it into the application. The shortcut add new task link enables you, just as in jotting down a “To-Do” list, to add new tasks unassigned or assigned to team members quickly and effortlessly.

  With the simple drag and drop functionality, tasks that have not yet been assigned can be passed to team members by simply dragging the task to the name of the team member.

  Any documents related to the tasks can be uploaded in the Documents uploaded section. Shared documents for the task are stored in a central point for team members to retrieve.

  The project manager is kept up to date with the progress of the project and the number of hours that have been dedicated to each task. This is done with the easy-to-use hour uploading system within the task view, when the task has been updated the team is informed with an e-mail keeping everyone up to date.

  
• 4:25

  Introduction to WhoDoes 2.0

   » ‎ RailsOnWave

  Upcoming WhoDoes 2.0 is improved with more intuitive and easy-to-use features.

  What’s new?

  WhoDoes 2.0 makes it possible to start managing a project in a just few minutes, even more efficiently. Using just one of the new features Fast Planning, assigning tasks to team members, defining due dates, implementing task priorities and keeping your project’s progress under control is done simply and easily with WhoDoes 2.0

  <center> </center>

  A new and innovative idea of sharing documents and e-mails has been built into WhoDoes 2.0, lost documents and e-mails will no longer be a problem. Team members will be kept up to date with WhoDoes’ new advanced centralized document and e-mail repository system which contains all the material that is related to the project with a new Project e-mail functionality.

  <center> </center>

  Limited resources for a project is something in the past, WhoDoes 2.0 introduces network Teamwork. This will enable you to invite people to your team who are part of the WhoDoes network and have chosen to be visible. Finding resources is easier and simple. Not only can you find people to assign to your project with the WhoDoes network but you don’t need to re-invite users that already have a WhoDoes account, they can simply be added as a team member.

  WhoDoes 2.0 has managed to integrate instruments into an online application making collaboration between team members and sharing of documents more efficient and easy for projects managed within the same office or projects with team members dispersed all over the world.

  
• April 23, 2008
• 18:39

  Playing with methods

   » ‎ RailsOnWave

  I’ve recently bought a copy of The Ruby Way and I’m getting deeper and deeper into the most hidden and powerful Ruby features.

  Yesterday I attempted for the first time to play with instance methods and I’m going to share what I discovered with you.

  To start I want to remind you one of the most known Ruby introspection method:

  
   "ciao".methods
  => ["send", "%", "index", "collect", "[]=", "inspect", ... ]
  
  

  by calling ‘methods’ on an object you get an array containing the name of all the methods that you can invoke on it (this include both its methods and the ones inherited from parent classes). But let’s go further: you can actually store a reference of one of these methods in a variable.

  
  txt = "ciao" 
  len = txt.method(:length)
  len.call
  => 4
  
  

  Now ‘len’ points to the method ‘length’ of the variable ‘txt’ (which is an istance of a String), so if we try to modify ‘txt’ then also ‘len’ change its result according to the changes:

  
  txt << " a tutti" 
  len.call
  => 12
  
  

  But we can do more, by calling ‘unbind’ on ‘len’ you can separate the method ‘len’ is pointing at (i.e.: length) from the istance at which you get it (i.e.: txt), getting the vanilla ‘length’ method that you can next ‘bind’ to a new variable.

  
  len_unbinded = len.unbind
  
  new_txt = "haloa!" 
  new_len = len_unbinded.bind(new_txt)
  new_len.call
  => 6
  
  

  That’s really impressive! And can turn pretty useful if you need to move a singleton method from one instance to another. There are more interesting features related to the Method class that can be found on the Method class RDoc, so if you are interested in this topic, or just curious, please have a look.

  
• April 16, 2008
• 1:14

  Create getter and setter on a valorized variable

   » ‎ RailsOnWave

  I noticed that none of the attr_* (attr_reader, attr_accessor and attr_writer) has the capability to let you assign a value to the variable you’re creating.

  This can be solved using the Class constructor method but it can lead you to define the initialize function just to make these assignements.

  So I created an attr_with_value method that can be added to the Object class in order to make it avaiable to all the Classes and that can let you use the following sintax:

  
  class Printer
    attr_with_value :pippo, 5
    attr_with_value :printer, Proc.new{|a| p "saying: #{a}" }
  end
  
  pr = Printer.new
  pr.printer.call("hello!")
  # "saying: hello!" 
  p pr.pippo
  # 5
  
  pr.printer = Proc.new{|a| p "whispering #{a}"}
  pr.printer.call("hello!")
  # "whispering hello!" 
  
  

  In the following snippet you can find the method:

  
  class Object
    def self.attr_with_value(name,value)
  
      class_eval <<-EOS
  
        define_method(name.to_s) do      
          @#{name}_starter.nil? ? value : @#{name} 
        end
  
        define_method(name.to_s+"=") do |val|
          @#{name}_starter = true; @#{name} = val
        end
  
      EOS
  
    end  
  end
  
  

  I’m looking for a way to improve it (in particular I’m trying to find a clever way to handle the initial assignment), so every suggestion is welcome!

  
• March 29, 2008
• 23:55

  Matz's speech from Euruko 2008

   » ‎ RailsOnWave
  <center></center>

  I’m writting this post from Prague’s Euruko 2008 Ruby conference. The conference is taking place inside the city university and it is organized by Czech and Slovak Ruby User Group.

  This morning we have attended to Matz’s speech titled ‘The Past, The Presen and The Future of Ruby’. Matz did a great comparison between all the current Ruby interpreters, JRuby, YARV, Rubinius. In particoular YARV impressed me much because, as explained by its author, Sasada Koichi, is up to 20x faster than the original Ruby interpreter!

  Next Matz talk about some of the new Ruby 1.9 features, as enumerator chain:

  
              ary.map.with_index{|x,i|
                  ...
              }
  
  

  and a cool way to interact with enumerators out of a block:

  
      e1= [1,2,3,4]
      e2=[10,11,4]
  
      loop {
          p e1.next+e2.next
      }  
      #=>11,13,7
  
  

  The last part of the speech was about Ruby 2.0, Matz sad that the keyword for this new release is scalability. Last but not least Matz talk about a new pre and post method hooks that will be implemented in Ruby 2.0 giving us more control on our functions (and maybe lead us to a design by contract paradigm in Ruby).

  
• March 21, 2008
• 19:36

  Ruby Pocket Session #3 - Callbacks

   » ‎ RailsOnWave

  ActiveRecord, callback and Ruby

  Active Records is the standard way that Rails provides to let your source code interact with databases. Active Records make available some standard callback functions to interact with their core tasks. Through callbacks you can intercept actions on databases, to perform some extra code before and after those actions. I found this topics interesting while refreshing my Ruby basics on the Ruby Pocket Reference and then I decided to go deeper through “Pro ActiveRecord – Databases with Ruby and Rails” (Amazon). I discovered this book some months ago reading Ruby Inside blog by Peter Cooper.

  There are 2 ways to add a callback to your code:

  • overwriting the method
  • using macros

  The best way to go through this, is using macros because of an inheritance hierarchy issue.

  I’ll show a small example. Let’s suppose we have to define a Party and Customer model classes and we want to write a log when they have saved on the database:

  Defining a callback using overwriting

  
  class Party < ActiveRecord::Base
    def after_save
      writelog_party_saved
    end
  end
  
  class Customer < Party
    def after_save 
      writelog_customer_saved
    end
  end
  
  

  Defining a callback using macro

  
  class Party < ActiveRecord::Base
    after_save :writelog_party_saved
  end
  
  class Customer < Party
    after_save :writelog_customer_saved
  end
  
  

  Using macros you preserve the inheritance chain of calls. So in the first case when you save a Customer record, no Party log is written. In the second case both callbacks are called, so the program writes a log for the Party record and one for the Customer record.

  
• March 17, 2008
• 19:37

  Observers: observing when changes have been made...

   » ‎ RailsOnWave

  I wanted to find a solution that only sends an email to notify when a change has been made to the page. I came across the Observer. It works great when you need to compare if the value have been changed from before the save button to after.

  This is how it works:

  In the controller, add the following at the top of the page:

  
  observer :mail_observer
  

  and in the model, add the following to get the changed attributes:

  
  attr_accessor :changed_attributes
  

  Create a new model:

  mail_observer.rb

  Your mail_observer should look similar to this, I call two callback methods before_save and after_save:

  
  class MailObserver < ActiveRecord::Observer
    #observe and the name of your model
    observe Task 
  
    def before_save(model)
  
     #Place the old values into a hash table only if it is not a new record being inserted
      old_attr = Hash.new
      if !model.new_record?
        old_model = model.class.find(model.id)
        old_attr = old_model.attributes
      end
  
      tmp_diff = Hash.new
  
      #delete the values in the hash table where the values have not changed, leaving you with the changed values
      model.attributes.delete_if do |key,value|
        old_attr[key] == value    
      end.keys.each do |k|
        tmp_diff[k] = old_attr[k]
      end
  
      model.changed_attributes = tmp_diff   
    end
  
  

  In the after_save function I check which values have changed by !model.changed_attributes[‘resource_name’].nil?, for example if a task that has been assigned to a person, is changed to another person, an email is sent to alert the new person that a task has been assigned to them.

  
    #the after save function you can check which values have been changed and do something for it, depending on what has changed
  
    def after_save(model)      
        #task resource_name
        if !model.changed_attributes['resource_name'].nil?
           #send an email to the person that has been assigned this new task
           puts 'the owner of this task is has been changed.' 
        end
   end
  

  This could be a good example to check when changes have been made to a page and to alert the changes that have been made.

  
• March 05, 2008
• 22:49

  RVG and SVuGy: create vector graphic with Ruby

   » ‎ RailsOnWave

  Today we’re going to discover two ways to create vectorial graphic with Ruby…

  Today we’re going to discover two ways to create vectorial graphic with Ruby;

  RVG

  The first way is called RVG and it’s part of the well-known Rmagick library. With RVG you can create custom shapes and then render them to images. Here there is a simple example (taken from the RMagic docs and modified a bit):

  
  require 'rvg/rvg'
  
  target = Magick::RVG.new.viewbox(0,0,200,200) do |targ|
      targ.g.styles(:stroke_width=>20, :stroke=>'#ff5600', :fill=>'#abd600') do |grp|
          grp.circle(90, 100, 100)
          grp.circle(60, 100, 100)
          grp.circle(30, 100, 100)
      end
  end
  
  rvg = Magick::RVG.new(258, 100) do |canvas|
      canvas.use(target, 0, 0, 100, 100)
      canvas.use(target, 100, 16.6667, 66.7, 66.7)
      canvas.use(target, 166.6667, 25, 50, 50)
      canvas.use(target, 216.6667, 30, 40, 40)
  end
  
  rvg.draw.write('nested_rvg.gif')
  
  

  And this is its output:

  <center></center> SvuGy

  This library acts in a very similar way with the small but noticeable difference that its output is not an image but a pure .svg file. Here is the code to product the same sample as above ( I know, it is not so DRY but i didn’t find smarter ways to do this, in part due to a lack of documentation):

  
  
  require 'SVuGy'
  
  drawing1 = SVuGy::Document.new(530, 200) do
  
      tri = group.style(:stroke_width=>20, :stroke=>'#ff5600', :fill=>'#abd600'){
        el2 = ellipse(100, 100, 90, 90)
        el1 = ellipse(100, 100, 60, 60)
        el0 = ellipse(100, 100, 30,