Ruby

Pragmatic Guide to JavaScript

Andrew Hunt — Wed, 08 Sep 2010 14:30:21 +0000

The latest member of our new Pragmatic Guide Series is now available in beta: Pragmatic Guide to JavaScript

Ruby Gurus to blog on RubyLearning

Satish Talim — Wed, 08 Sep 2010 04:02:47 +0000

Ruby Gurus to blog on RubyLearning

RubyLearning is happy to announce that the following Ruby Gurus would be individually writing a guest blog post here starting 20th Sept. 2010. The focus of the blog post would be towards Ruby Newbies. These gurus are:

20th Sept. – Geoffrey Grosenbach, USA.
21st Sept. – Sau Sheong Chang, Singapore.
22nd Sept. – Jeff Schoolcraft, USA.
23rd Sept. – Karmen Blake, USA.
24th Sept. – Julio Javier Cicchelli, Netherlands.
25th Sept. – David A. Black, USA.
27th Sept. – Matt Aimonetti, USA.
28th Sept. – Martin Sadler, UK.
29th Sept. – Noel Rappin, USA.
30th Sept. – Damien Tanner, UK.
1st Oct. – Elise Huard, Belgium.

More blog posts from other Ruby Gurus are in the pipeline.

Watch this space.

Technorati Tags: Ruby Gurus, Ruby, Programming, Ruby Newbies

Automatic Flushing: The Rails 3.1 Plan

wycats — Wed, 08 Sep 2010 01:05:34 +0000

preamble: this post explains, in some detail, how we will implement a nice performance boost for Rails developers. Understanding the details might help gain the full benefits of the optimization, but you will gain some benefits even if you have no idea how it works.

As you’ve probably seen, DHH announced that we’d be looking at flushing in Rails 3.1 to improve the client-side performance of typical Rails applications.

The most obvious solution, and one that already exists in plugin form, is to allow a layout to have a new flush method, which would immediately flush the contents of the layout to the browser. By putting the flush method below the JavaScript and CSS includes, the browser could begin downloading and evaluating those static assets while the server continues building the page.

Unfortunately, this solution has a major problem: it requires a fairly significant change in the current model of how people build applications. In general, for performance optimizations (including client-side optimizations), we like to make the default as fast as possible, without asking people to understand a brand new paradigm, centered around the optimization.

The problem lies in the fact that a Rails layout is essentially a template with a bunch of holes to fill in.


  
    <%= yield :title %>
    <%= javascript_include_tag :defaults %>
    <%= yield :extra_javascripts %>
    <%= stylesheet_link_tag :defaults %>
    <%= yield :extra_stylesheets %>
  
  
    <%= yield :sidebar %>
    <%= yield %>

I this simple example, each yield is a slot that is filled in by the template (usually via content_for). In order to achieve this, Rails evaluates the template first, which populates a Hash with each piece of content. Next, it renders the layout, and each yield checks the Hash for that content. In short, because of the way layouts work, Rails renders the template first, and then the layout.

To get around this, one option would be to say that everything before the flush must not use yield, and must be able to run before the template. Unfortunately, it’s somewhat common for people to set up a content_for(:javascripts) in a template, to keep the JavaScript needed for a particular snippet of HTML close to the HTML. This means that not only does the user have to be careful about what can go above and below the flush, he can no longer use content_for for things high up in the template, which is a fairly significant change to the overall design of Rails applications.

For Rails 3.1, we wanted a mostly-compatible solution with the same programmer benefits as the existing model, but with all the benefits of automatic flushing. After a number of very long discussions on the topic, José Valim came up with the idea of using Ruby 1.9 fibers to jump back and forth between the template and layout.

Let’s start by taking a look at a very simplified version of the current Rails rendering pipeline. First, we set up a Buffer object purely for logging purposes, so we can see what’s happening as we push things onto the buffer.

module Basic
  class Buffer < String
    def initialize(name, context)
      @name    = name
    end
 
    def <<(value)
      super
 
      puts "#{@name} is pushing #{value.inspect}"
    end
  end
end

Next, we create a simple version of ActionView::Base. We implement the content_for method simply, to print out a bit of logging information and stash the value into the @content_for Hash. Note that the real version is pretty similar, with some added logic for capturing the value of the block from ERB.

module Basic
  class ViewContext
    def initialize
      @buffer      = Buffer.new(:main, self)
      @content_for = {}
    end
 
    def content_for(name, value = nil)
      value = yield if block_given?
      puts "Setting #{name} to #{value.inspect}"
      @content_for[name] = value
    end
 
    def read_content(name)
      @content_for[name]
    end
  end
end

Next, we create a number of methods on the ViewContext that look like compiled ERB templates. In real life, the ERB (or Haml) compiler would define these methods.

module Basic
  class ViewContext
    def layout
      @buffer << ""
      @buffer << yield(:javascripts).to_s
      @buffer << yield(:stylesheets).to_s
      @buffer << ""
      @buffer << yield.to_s
      @buffer << yield(:not_existant).to_s
      @buffer << ""
      @buffer
    end
 
    def template
      buffer =  Buffer.new(:template, self)
      content_for(:javascripts) do
        ""
      end
      content_for(:stylesheets) do
        ""
      end
      puts "Making a SQL call"
      sleep 1 # Emulate a slow SQL call
      buffer << "Hello world!"
      content_for(:body, buffer)
    end
  end
end

Finally, we define the basic rendering logic:

module Basic
  class ViewContext
    def render
      template
      layout { |value| read_content(value || :body) }
    end
  end
end

As you can see, we first render the template, which will fill up the @content_for Hash, and then call the layout method, with a block which pulls the value from that Hash. This is how yield :javascripts in a layout works.

Unfortunately, this means that the entire template must be rendered first, including the (fake) slow SQL query. We’d prefer to flush the buffer after the JavaScripts and CSS are determined, but before the SQL query is made. Unfortunately, that requires running half of the template method, then continuing with the layout method, retaining the ability to resume the template method later.

You can think of the way that templates are currently rendered (in Rails 2.x and 3.0) like this:

Unfortunately, this makes it very hard to get any more performance juice out without asking the end-developer to make some hard choices. The solution we came up with is to use Ruby 1.9 fibers to allow the rendering to jump back and forth between the template and layout.

Instead of starting with the template and only rendering the layout when ready, we’ll start with the layout, and jump over to the template when a yield is called. Once the content_for that piece is provided by the template, we can jump back to the layout, flush, and continue rendering. As we need more pieces, we can jump back and forth between the template and layout, flushing as we fill in the holes specified by the yield statements.

The implementation is mostly straight-forward:

require "fiber"
 
module Fibered
  class ViewContext < Basic::ViewContext
    def initialize
      super
      @waiting_for = nil
      @fiber       = nil
    end
 
    def content_for(name, value = nil)
      super
      @fiber.resume if @waiting_for == name
    end
 
    def read_content(name)
      content = super
      return content if content
 
      begin
        @waiting_for = name
        Fiber.yield
      ensure
        @waiting_for = nil
      end
 
      super
    end
 
    def layout
      @fiber = Fiber.new do
        super
      end
      @fiber.resume
      @buffer
    end
 
    def render
      layout { |value| read_content(value || :body) }
      template
      @fiber.resume while @fiber.alive?
      @buffer
    end
  end
end

For our fibered implementation, we’ll inherit from Basic::ViewContext, because we want to be able to use the same templates as we used in the original implementation. We update the content_for, read_content, layout and render methods to be fiber-aware. Let’s take them one at a time.

def layout
  @fiber = Fiber.new do
    super
  end
  @fiber.resume
  @buffer
end

First, we wrap the original implementation of layout in a Fiber, and start it right away. Next, we modify the read_content method to become Fiber-aware:

def read_content(name)
  content = super
  return content if content
 
  begin
    @waiting_for = name
    Fiber.yield
  ensure
    @waiting_for = nil
  end
 
  super
end

If the @content_for Hash already has the content, return it right away. Otherwise, say that we’re waiting for the key in question, and yield out of the Fiber. We modify the render method so that the layout is rendered first, followed by the template. As a result, yielding out of the layout will start the template’s rendering.

def render
  layout { |value| read_content(value || :body) }
  template
  @fiber.resume while @fiber.alive?
  @buffer
end

Next, modify the content_for method so that when the content we’re waiting for is provided, we jump back into the layout.

def content_for(name, value = nil)
  super
  @fiber.resume if @waiting_for == name
end

With this setup, the layout and template will ping-pong back and forth, with the layout requesting data, and the template rendering only as far as it needs to go to provide the data requested.

Finally, let’s update the Buffer to take our fibered implementation into consideration.

module Basic
  class Buffer < String
    def initialize(name, context)
      @name    = name
      @fibered = context.fibered?
    end
 
    def <<(value)
      super
 
      if @fibered
        puts "Flushing #{value.inspect}" if @fibered
      else
        puts "#{@name} is pushing #{value.inspect}"
      end
    end
  end
 
  class ViewContext
    def fibered?
      false
    end
  end
end
 
module Fibered
  class ViewContext
    def fibered?
      true
    end
  end
end

Now that we’re rendering the layout in order, we can flush as we go, instead of being forced to wait for the entire template to render before we can start flushing.

It’s worth mentioning that optimal flushing performance will be based on the order of the content_for in your template. If you run your queries first, then put the expensive template rendering, and only finally do the content_for(:javascript) at the end, the flushing behavior will look like this:

Instead of flushing quickly, before the SQL call, things are barely better than they are in Rails 2.3, when the entire template must be rendered before the first flush. Because things are no worse, even in the worst-case scenario, we can make this the default behavior. Most people will see some benefit from it, and people interested in the best performance can order their content_for blocks so they cause the most beneficial flushing.

Even for people willing to put in the effort, this API is better than forcing a manual flush, because you can still put your content_for blocks alongside the templates that they are related to.

Look for this feature in Rails 3.1!

Small Caveat

For the purposes of this simplified example, I assumed that content_for can only be run once, immediately setting the value in the @content_for Hash. However, in some cases, people want to accumulate a String for a particular value. Obviously, we won’t be able to flush until the full String for that value is accumulated.

As a result, we’ll be adding a new API (likely called provide), which will behave exactly the same as content_for, but without the ability to accumulate. In the vast majority of cases, people will want to use provide (for instance, provide :sidebar), and get all the benefits of autoflushing. In a few cases, people will want to be able to continue accumulating a String, and will still be able to use content_for, but the template will not return control to the layout when that happens.

Also note that this (fairly detailed) explanation is not something that you will need to understand as a Rails developer. Instead, you will continue to go about your development as before, using provide if you have just a single piece of content to add, and content_for if you have multiple pieces of content to add, and Rails will automatically optimize flushing for you as well as we can.

The Ruby Show #132: There Be Dragons

Jason Seifer and Dan Benjamin — Tue, 07 Sep 2010 22:31:00 +0000

In this episode, Jason and Dan bring you the latest Ruby and Rails news. They touch on the latest 2.x release of rails, an awesome css plugin, and of course, code from the GitHubs.

September 7, 2010: On Writing Bad Code

noelrap — Tue, 07 Sep 2010 12:38:00 +0000

I’ve been working on my tutorial session for WindyCityRails (tickets still available…). The session is about how to test when you are working in a legacy app that doesn’t have tests.

Naturally, that requires some legacy code for the attendees to work with during the tutorial. My own worst Rails messes are either back in the 1.2.x time frame or I don’t have access to them any more. I don’t have the right to distribute legacy code that I have inherited, and most of those people wouldn’t want me calling their code a junkpile in public.

So I’ve been writing a faux-legacy application, or at least enough of one to make the needed points in the tutorial. The idea stumped me for a bit because the app needs to be both complex enough to plausibly show the issues in legacy testing and simple enough so that setup and changes can actually happen in a short workshop.

Eventually, I hit on the following guidelines for writing deliberately bad code:

Aggressive corner cutting on features that aren’t essential to the presentation.
Don’t look anything up and don’t use gems or plugins, not least of which to prevent setup issues.
Make no effort to put things in the “right” place.
Work quickly, without design and never go back to clean up a mess.
Randomly, do something a little bit less elegantly than normal. Oh, and some metaprogrammy Ruby things were off limits, assuming I was writing as somebody who didn’t know Ruby that well.

And I think I got some nicely tangled code rather quickly.

At this point I think I’m supposed to say one of two things:

Boy I sure was able to write that code fast without the pesky rules! I guess that TDD stuff isn’t that great after all.
Boy, I sure wrote nasty code without those pesky rules! I guess that TDD stuff really is great after all.

I think I believe the second point more than the first. It’s hard to look at this code and not see some major pain coming in the future. That said, you have to acknowledge the emotional power of seeming to write fast code.

Because I did go pretty fast here, and I got a satisfying amount of app built in a relatively short number of hours with a very continuous novelty burst in my head from seeing new things in a browser.

The temptation to say, “I was deliberately writing ugly code. If I just stopped doing that, then boy, I could go really fast and not use TDD, I can control bugs without TDD.” And the thing is, that’ll be true for a while. Maybe a long time, if you’re pretty good and working by yourself.

This is related to the very seductive idea that your project doesn’t need to use Agile methods because you can control your changes up front. In both cases, you go quickly mostly by ignoring the inevitability of anything changing in the future (who cares how tangled the code is if nobody ever has to modify it…)

In the end, though, change is coming. So the trick to working in a legacy environment is taking code that was never written to allow change and making it more amenable to change.

Filed under: Agile

Episode 230: Inherited Resources

Ryan Bates — Mon, 06 Sep 2010 07:00:00 +0000

Inherited Resource simplifies RESTful controllers by providing default actions which can be customized through inheritance.

Matz Ruby World Keynote

chad — Mon, 06 Sep 2010 05:20:00 +0000

The following is my real time transcription of the translation of Matz’s speech at Ruby World 2010. I was typing as fast as I could while he spoke, and I probably made some mistakes. I might have left out some words or sentences. If anything doesn’t make sense, assume it’s my fault and not Matsumoto-san’s. Anyway, I enjoyed Matz’s keynote and thought other English speakers might like a chance to see what he said.

I’m Matsumoto

I Started Ruby in 1993 at NaCL:http://www.netlab.jp/. When I joined the company after graduating from college, I didn’t have much to do at the time. I was not fired fortunately. But I had plenty of time so I started to work on Ruby as a side project.

So at the time, there was ONE user of Ruby. Then I started to develop Ruby with some other friends.

In 1995, Ruby was released and distributed over the internet for general use. At the time, people on usenet got interested in Ruby and gave me some feedback. Also we used a mailing list to distribute information on Ruby.

So within days, about 200 people got involved. So in 1995, the number of people who knew something about Ruby was about 200.

Even after that, Ruby was known to a relatively limited number of people.

Then in 1999, I published a book called Object Oriented Scripting with Ruby. This was the first book on Ruby. It’s only natural. Who else is going to write a book on Ruby, right??

At the time, this sold pretty well. Cumulatively, we sold almost 20,000 copies. I’m sure I’m allowed to discuss this number. Probably it’s only 17,000 in real numbers. This was in Japanese, so Ruby was known to the whole nation. So in 1999, Ruby was known to a lot more people. More engineers and programmers knew about the language.

I started to hear from many people that they knew about Ruby.

In year 2000, a book in English was published. Many people in the world came to know about Ruby.

Then in 2004, Ruby on Rails was released. Of course, most people know about this Web application framework. Ruby on Rails is very productive compared to competing frameworks in other languages. There was an active discussion on the comparison of performance. It was welcomed by many people. We estimate that the number of users grew to 100,000 people in 2004.

In 2008, US-based Gartner released a survey. In the report, Gartner estimated that the total number of Ruby users reached 1,000,000. This was a huge number as you can see.

In the same report, the reporter predicted that in five years (2013) the total number of users would be 4,000,000. Ruby is open source. You don’t have to pay anything to use it. You just download it. It is therefore very difficult to know how many people are using it. I created Ruby myself and I don’t know how many people are using it, so I’m not sure how Gartner reached their conclusion. But anyway, 4,000,000 people are predicted to be using Ruby in 2013.

So in 20 years, this project which started with one person may have increased from 1 to 4,000,000 users. This is beyond the normal growth rate of a technology.

This period of Ruby’s popularity was due to the popularity of Ruby on Rails.

There is a ccompany called Tiobe Software which is a software company in the US. Their Tiobe Index rates the popularity of programming languages using Google, Yahoo, Microsoft, and other search engines to rate the popularity of languages on the internet. Back in 2009, according to Tiobe index, Ruby was ranked #10. And in 2008, it was ranked #9.

In this year, 2010, it was demoted to #12.

You may have a concern about the future of Ruby, but if you drill down deeper, you will see: objective-c is getting more popular, driven by iPad, iPod, etc. development. Objective-C is required. So it jumped form 42 to 11. And Go by Google was released in April of last year. So where it didn’t exist previously it jumped up to #15.

As you can see, Ruby represents 2.221% of programming language references according to Tiobe. That’s good.

So don’t have a concern about this.

But this marks a very interesting symptom. The end of the ruby “bubble”. When I joined the company, the bubble economy was still there. Then it collapsed and caused a lot of trouble. A “bubble” is not sustainable. Bubbles are therefore undesirable.

There are many comedians and musicians named as “one-hit wonders”. I don’t want Ruby to become that.

The life expectancy of a programming language is pretty long. Fortran was created in the 1950s. I want Ruby to be like this. That’s why this presentation is called “Sustainable Ruby”. The question is how to maintain Ruby’s high level of quality and the high level of quality of the people.

So in order to implement “sustainable ruby”, we must first discuss the benefit of Ruby. Benefit is very important for Ruby to be sustainable.

Benefit #1: Productivity. One of the reasons that Ruby is quite popular is that its productivity is quite high. An embodiment of this is Ruby on Rails. When Rails was released, it was often cited that people would say that Rails had 10x productivity over java. Ruby developers didn’t really believe this, but a specific developer in the US wrote an article saying that he felt that HIS productivity over Java when switching to Rails was 10x. In 2005 and 2006, this one sentence caused a lot of arguments and discussion.

After several years of discussion and usage of Ruby on Rails, it may not be 10x but there are many cases where you can enjoy the productivity of Ruby on Rails over Java.

Also, another example of how Rails is productive is that it can take only 15 minutes to develop a web application. In 2004 at a Brazilian conference, David Heinemeier Hansson demonstrated web application development using Ruby on Rails. Without any preparation, no design, no database, he started to create a blog application. You could create articles, list them, etc. He created this application in 15 minutes. In 2004, creating an application in 15 minutes it was astonishing. It was great marketing to do that.

I’m a software engineer and I’m not very interested in marketing. But that video was a huge contributor to making Ruby on Rails popular. Ruby itself didn’t have any marketing, but Ruby on Rails promoted Ruby as well.

Was the Rails framework the sole reason behind the productivity boost when using it? I don’t think so. Ruby itself also makes the productivity possible.

Post-Rails frameworks.
Merb
Sinatra
Ramaze
Rails 3

Merb was emerging as a post-Rails framework, but it was quite unique in open software. Merb and Rails jointly created a new framework in the form of Rails 3. Also, Rails 3 is inheriting some of the Merb characteristics. Totally new framework by combining/merging different frameworks.

So far I’ve been talking about the benefits that Ruby can provide in order to make Ruby sustainable.

The second element is the Potential the language can demonstrate. Now we have the technology and the technology is convenient and we can create some benefits. But we need to have potential in the Language for people to make investment.

Around Ruby we have much new technology. Ruby on Rails, for example, introduced innovations in Web development. It wasn’t the first web framework. Not even the first Web framework in Ruby. There were already a lot of web application frameworks in Ruby when Rails was released. But under the circumstances, Ruby on Rails implemented new ideas that triggered productivity enhancements in Ruby AND other languages (python, etc.). So Ruby on Rails had a huge impact on the web application development arena.

Whenever a new technology is created, the surrounding areas also enjoy the benefits of this technology. Not all new technologies will be successful, but some of them will really boost the entire IT industry.

We do see some of that trend in the industry. To support the new technology we need to have smart engineers (hackers). The smart engineers usually come to the interesting technology. Whenever there’s new technology that’s created, it invites the smart engineers who then create new technology. This is a positive cycle. Ruby is one of these positive cycle enforcers.

Benefit, Potential, and….

Passion

The author of The Passionate Programmer, Chad Fowler, is here. I feel embarrassed to say something about him before his keynote. But I have to say this. He is right to emphasize passion. Many people are passionate about ruby. Engineer passion is very important. Passion is key.

In the US there is a conference called RubyConf:http://rubyconf.org. The first one was held in Tampa Florida. There were only 34 attendees at the first conference. Right now we have more than 500 people attending. If the venue could handle it we could probably fit 700 or 1000. They actually limit the number of attendees. They sell out every year. This year RubyConf will be held in Matsue’s sister city, New Orleans. It will be the 10th. It is the longest running Ruby conference on the globe.

Euruko. Poland, Barcelona, Berlin, Prague. On the last day, Euruko always invites speakers to bid on where Euruko should be. Speakers make their case and the location of the next Euruko is voted on.

Two weeks ago we had RubyKaigi. It was held in Tsukuba City. Not in Tokyo. I graduated from Tsukuba univeristy. It made me feel like i was going home. We had about 700 people at RubyKaigi this year. RubyConf will have 500 (ed: actually 600 to 650). The biggest conference is held in Japan.

As you can see here in this venue as well Ruby World has so many people from so many countries. I would say that the IT industry is japan is becoming truly internationalized. We have a disadvantage in Matsue because it’s so remote, but the passion of the Rubyists makes it possible.

We also have regional Ruby conferences in India, China, Brazil, all over the US, etc. They also have another conference called RailsConf:http://railsconf.org, which is operated by a professional event management company (ed: and Ruby Central). They had 1800 people. So that really boosts Ruby.

Startup passion. I’m going to talk about US companies, but there are many venture companies in Silicon valley who are very interested in Ruby. More than 60% of VCs use Ruby to provide the system. Among the famous ones known to Japan includes Twitter. As a startup, they implemented everything using Ruby from bottom to top. Currently they have 100s of millions of users. Much of the RUby has been replaced but if you access twitter you can still see twitter driving the system.

As of last year another acronym was introduced “ARC”. Agile, Ruby/Rails, Cloud. I’ve heard that VCs ask startups who aren’t using Ruby, “Why not?” Investors are pressuring startups to use Ruby. “It’s faster, so if you can shorten your release by one month why not use Ruby?”, they say.

A few years ago when startups were getting started, they wanted to attract smart engineers, so they used Ruby to attract them.

Executives’ passion: Productivity is the key. It’s not just the engineers who are passionate about Ruby. Productivity is one of the biggest factors for businesses. Executives started to realize the importance of using a productive language. Productive languages drive profit. Some executives are finding hope in Ruby.

Differentiation can be found by using Ruby. The japanese IT industry is characterized by conservatism, so many may be reluctant to use Ruby. But by making the decision to use Ruby, they may differentiate themselves. There is also the possibility to change the entire industrial structure by switching to Ruby and other open source technologies, driving more SMBs.

In Japan, major IT companies receive contracts and subcontract to others. But with Ruby and smart engineers, these can be driven to small businesses which can innovate. This drives hope.

Motivation drives Hope

for Food
for Money
These are very pragmatic

for Good Cause
But some people might make a bigger attempt to change the world.

Many people are finding hope in Ruby. Many found potential in Ruby.

Not all have succeeded. Some are extremely successful. Some are not. What made the difference?

In some cases, the benefit was not enough. Or people couldn’t see the potential. But the biggest factor was PASSION! How passionate or decisive they were made the difference.

Lots of people love Ruby. Pictured here (ed: he shows a picture in his slide) are the smiling faces of the staff of the RubyKaigi. This is not organized by professionals. 700 turnout is already beyond its technical limits. But when we ran the survey, most people were satisfied by the conference. It’s miraculous considering the tough circumstances. But these people are passionate.

Many people are surrounding ruby. Hacker,s engineers, executives. They LOVE Ruby.

Of course I love Ruby myself. It’s my child. Every day I am expanding my affection for Ruby. There are so many people out there that love Ruby. As a Japanese, I’m reluctant to say “love”. Actually one guy said “I love you”. I am poor at English. I was very embarrassed For Japanese, it’s difficult to express love in a direct fashion. Of course that guy didn’t mean “love”. He just loved Ruby. Like a strong kinship.

Many people love Ruby. Let me give you some examples:

NaCl. When i started at NaCl, Inoue-san he actually picked me up and allowed me to work on this. Back in 1995, there was no way to know if Ruby would be used by anyone. But the president, Mr. Inoue-san had the faith and the vision to hire me and let me work on Ruby. He gave me plenty of time to work on Ruby. It’s all possible because of him.

In 2006, the Matsue mayor actually visited our lab. We would like to use Ruby to revive the city. I had to reply, “Are you out of your mind?” Can you believe this person would try to revive our city using Ruby? Many people living in many places outside of Matsue, so I said maybe it’s difficult but someone from the city told me the Mayor was very serious about this. The mayor himself actually expressed his desire to use Ruby. So as a local government, Matsue city is committed to promote Ruby, which is very very exceptional on examination. How much contribution we’re making to the city really is unknown.

This is Mr. Mizoguchi the Shimane governor. I don’t know how to show my appreciation to him. I’d like to take this opportunity to thank him again. There are many other local governments who are interested in using Ruby to revive their city. But the question is how passionate are the top management or the governor or mayor? Even if the promoters work hard, unless top management is passionate about the promotion it’s not going to work.

One exceptional case is the governor of Fukuoka. A rival of Shimane . For some reason he really loves Ruby. I’m living her and he’s in Fukuoka. There’s no relation. But Fukuoka is committed to using Ruby and they have organized the Fukuoka award and they have the Ruby Business Commons headquarters.

Here is a noodle called Ruby on Matsue Ramen. The maker of this Ramen sent me an email. The maker of this has no connection to Ruby, but he has a local businesses and wants to promote Ruby. He offered to include the Ruby logo on this noodle to contribute to sales. It’s remarkable. This person volunteered to make Ruby Ramen for us without us asking.

And thanks to all the efforts of all these people, Ruby is exciting right now.

I have been engaged in Ruby for 17 years and i think it’s making sense for me to be passionate about Ruby. But many others are passionate about Ruby. I don’t understand why, but Ruby is loved. Love is driving Ruby.

With the support of so many people, we are able to hold this Ruby World conference for the next two days. And I hope that for these days we can fully discuss the benefits of Ruby so that it will be helpful to what you do. 17 years ago I was the only one person who used Ruby. But over 17 years, people who are using Ruby (more than 1,000,000 people) in university Research, implemented in IT industry, etc.

Some of the things Ruby users are discussing are quite inspiring. Without this conference we can’t attract all of these great people to Matsue people. We should take advantage of this opportunity.

Ruby is supported by passion. And by love.

One more thing: The Ruby Association which I chair provides Ruby programmer certification. We have this announcement today that we have created a new “Gold” certification for Ruby programmers. This requires a higher level of skill. If you go to the Ruby Association home page, there is a press announcement which explains what you need to do to be qualified as Ruby “Gold” certified.

Thank you.

New Course: Ruby Programming 101

Satish Talim — Mon, 06 Sep 2010 03:16:48 +0000

Introducing an intensive, online course for beginners that helps you get started with Ruby programming.

What’s Ruby?

According to http://www.ruby-lang.org/en/ – “Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.”

Yukihiro Matsumoto, the creator of Ruby, in an interview says – “I believe people want to express themselves when they program. They don’t want to fight with the language. Programming languages must feel natural to programmers. I tried to make people enjoy programming and concentrate on the fun and creative part of programming when they use Ruby.”

What Will I Learn?

In the Ruby programming 101 course, you will learn the essential features of Ruby that you will end up using every day.

Who’s It For?

An absolute beginner but with some experience in some other programming language.

Mentors

Satish Talim, Satoshi Asakawa, Victor Goff III and others from the RubyLearning team.

Dates

The course starts on Saturday, 23rd Oct. 2010 and runs for two months.

Course Fees

Early Bird Registration Discounts

For the first 30 registrations, Course Fee: US$ 9.95 per participant.
After the first 30 registrations, Course Fee US$ 14.95 per participant.

Hurry, registrations have started.

At the end of this course you should have all the knowledge to explore the wonderful world of Ruby on your own.

How do I register?

You first need to register on the site and then enroll into the course.

6th Sept. – So far the registered participants are from:

Phnom Penh, Cambodia
Paris, France
Puerto Rico
Ljubljana, Slovenia
Yalova, Turkey
Crystal, USA
Los Angeles, USA

Also, many of you wrote in asking for details on how the course works. Here are some of the details:

Important:

Once the course starts, you can login and start with the lessons any day and time and post your queries in the forum under the relevant lessons. Someone shall always be there to answer them. Just to set the expectations correctly, there is no real-time ‘webcasting’.

Methodology:

The Mentors shall give you URL’s of pages and sometimes some additional notes; you need to read through. Read the pre-class reading material at a convenient time of your choice – the dates may be specified only as a guideline. While reading, please make a note of all your doubts, queries, questions, clarifications, comments about the lesson and after you have completed all the pages, post these on the forum under the relevant lesson. There may be some questions that relate to something that has not been mentioned or discussed by the mentors thus far; you could post the same too. Please remember that with every post, do mention the operating system of your computer.
The mentor shall highlight the important points that you need to remember for that day’s session.
There could be exercises every day. Please do them.
Participate in the forum for asking and answering questions or starting discussions. Share knowledge, and exchange ideas amongst yourselves during the course period. Participants are strongly encouraged to post technical questions, interesting articles, tools, sample programs or anything that is relevant to the class / lesson. Please do not post a simple "Thank you" note or "Hello" message to the forum. This forum is subscribed by several people, so please be aware that these messages are considered as noises by many people.

Outline of Work Expectations:

Most of the days, you will have exercises to solve. These are there to help you assimilate whatever you have learned till then.
Some days may have some additional assignments / food for thought articles / programs
Above all, do participate in the relevant forums. Past participants will confirm that they learned the best by active participation.

Some Commonly Asked Questions

Qs. Is there any specific time when I need to be online?
Ans. No. You need not be online at a specific time of the day.
Qs. Is it important for me to participate in the course forums?
Ans. YES. You must Participate in the forum(s) for asking and answering questions or starting discussions. Share knowledge, and exchange ideas amongst yourselves (participants) during the course period. Participants are strongly encouraged to post technical questions, interesting articles, tools, sample programs or anything that is relevant to the class / lesson. Past participants will confirm that they learned the best by active participation.
Qs. How much time do I need to spend online for a course, in a day?
Ans. This will vary from person to person. All depends upon your comfort level and the amount of time you want to spend on a particular lesson or task.
Qs. Is there any specific set time for feedback (e.g., any mentor responds to me within 24 hours?)
Ans. Normally somebody should answer your query / question within 24 hours.
Qs. What happens if nobody answers my questions / queries?
Ans. Normally, that will not happen. In case you feel that your question / query is not answered, then please post the same in the thread – “Any UnAnswered Questions / Queries”.
Qs. What happens to the class (or forums) after a course is over? Can you keep it open for a few more days so that students can complete and discuss too?
Ans. The course and its forum is open for a month after the last day of the course.

Remember, the idea is to have fun learning Ruby.

Technorati Tags: Ruby course, Ruby, Ruby Training, Programming

Ruby on Rails 2.3.9 Released

Jeremy Kemper — Sat, 04 Sep 2010 21:45:00 +0000

We’ve released Ruby on Rails 2.3.9 (gem and git tag) to extend the 2.3.8 bridge a few steps closer to Rails 3 and Ruby 1.9. If your app runs on Rails 2.3.9 without deprecation warnings, you’re looking good for an upgrade to Rails 3.

Deprecations

Changes i18n named-interpolation syntax from the deprecated Hello {{name}} to the 1.9-native Hello %{name}.
Replaces Kernel#returning with Object#tap which is native to Ruby 1.8.7.
Renames Array#random_element to Array#sample which is native to Ruby 1.9.
Renames config.load_paths and .load_once_paths to the more accurate config.autoload_paths and .autoload_once_paths.

Along with these deprecations come a broad array of bugfixes and minor tweaks. Read the commit log for the full story.

Onward to 3.1!

Sep 3, 2010: Twitter for iPad and Other Craziness

noelrap — Fri, 03 Sep 2010 12:05:20 +0000

Book Status

RSpec chapter edits complete, a dozen or so errata squashed, and hopefully we’ll get beta 7 out. I suspect it’ll be after Labor Day, though. I’m pleased with how this one turned out. The RSpec chapter is a challenge — I’m literally squeezing a book’s worth of content into a chapter, but I think it covers the major points clearly.

Since I haven’t posted it in a while, you can buy the book here and on Amazon.

That, I think, pretty much ends the content that had some basis in the Lulu book, moving us into the one or two chapters that I need to write from scratch, as well as at least one chapter that has been obsoleted over the summer (BlueRidge). Still, getting closer.

WindyCityRails Update

Still seats available for my WindyCityRails tutorial. Right now, I’m trying to coordinate what I want to say with the faux-legacy app I’m building for people to practice on. The faux app needs to look legacy-ish, but still be easy enough to install and work with that something meaningful can be done in a three hour tutorial. Interesting problem.

More iPad

Two possible changes in my iPad app mix:

Twitter app replacing Osfoora HD

For all that it’s kind of insane, I really like the official Twitter iPad app. It’s super polished, and although I’m not convinced that the actual implementation of the overlapping tabs is optimal, I think the basic idea is great. One interesting point is that they clearly have chosen to favor a specific kind of Twitter user.

The overlapping tab works well at letting you see data related to a tweet (usually the contents of a link) and still see your account side bar and some of your timeline. It’s quite pretty, aggressively bold in the way the original Tweetie app was, and useful. I appreciate that it’s fewer clicks and generally easier to follow links on a lot of tweets in short succession, which I do a lot. I do think it’s weird that the browser tab kind of half-sticks around even after you go back to your timeline, and it’s easy to miss the spots where the browser tab slides back (as opposed to trying to horizontal scroll the browser window). A lot of people are reporting that it’s hard to figure out how to move the panes — I think it could be clearer in-app.

But, I like that it keeps my place when I change orientation — which is Osfoora’s most annoying non-feature. I like the layout in general, I think it gets the natural proportion of a twitter stream right (a lot of the other Twitter apps make the stream really wide, which feels strange to me), and it feels very polished and responsive.

Now I wish that the Mac Tweetie that I bought MacHeist in order to get an early beta might actually come out. Sigh.

River of News replacing Reeder, Maybe.

I’m not sure about this one. River of News is a simple RSS reader that displays articles in a basic River of News style, meaning one after another.

It’s not as pretty or full featured as Reeder, but it’s also less inscrutable and I tend to like the general layout.

Right now it seems as though River of News works better when I’m reading most of the articles in a feed or folder, because it scrolls better than Reeder does. But since Reeder has the mini previews, it’s faster if I plan on skipping most of a feed. Still wondering which will work best.

Filed under: iPad, Twitter