Rubyists in Pune

Technorati: In top 50,000

2006-10-17T17:01:00.000+05:30

Today, the Learning Ruby site was ranked 48,577 by Technorati. This is good news especially since the site's been 'live' for only a month now.

Rank 48,577 means that the number of blogs, plus one, that have more than 58 distinct blogs linking to them.

Technorati Tags: Technorati: In top 50,000
Blogs linking to this article

Socket Programming in Ruby

2006-10-16T13:01:00.000+05:30

I have just published an article that explains how one can do Socket Programming in Ruby.

I had been searching the internet for some information on Socket Programming in Ruby, but had not been successful. The article is a result of that. Do send me your feedback on how you found the article. Was it useful to you? I look forward to your inputs.

Technorati Tags: Socket Programming in Ruby
Blogs linking to this article

The Ruby Edge

2006-10-16T07:35:00.000+05:30

The Ruby Edge is a new community driven web site for Ruby and Ruby On Rails news, tips, tricks, tutorials, books, and jobs. It's a Digg
style site with user voting, commenting, and categorization of user submissions.

Please stop by and share your Ruby/Rails knowledge.

Technorati Tags: The Ruby Edge
Blogs linking to this article

Ruby Certification

2006-10-11T10:25:00.000+05:30

The JavaBlackBelt Certification Community has added a Ruby - Basic Certification exam. recently. The objective of this certfication is:

To test knowledge of the language core syntax and OO concepts. You should understand that Ruby is a genuine object-oriented language and everything it manipulates with is objects. No specific API knowledge is required. Only the most frequently used built-in classes and methods are covered. The knowledge of any external libraries is not necessary. The given exam covers Ruby 1.8.x features and syntax.

After completing the free, web-based course Learning Ruby, it would be beneficial for you to give this test. All the best.

Technorati Tags: Ruby Certification
Blogs linking to this article

Free Study Notes on Ruby

2006-10-09T10:59:00.000+05:30

I have created a small pdf version of my Ruby study notes. This can be downloaded from here. I am hopeful that it would be useful for students making a shift to Ruby / Rails and as always feedback and corrections are welcome in the comments.

The entire Learning Ruby courseware is available online here.

Technorati Tags: Free Study Notes on Ruby
Blogs linking to this article

Free Web-based Ruby Course

2006-09-15T09:37:00.000+05:30

The free, web-based Ruby course being conducted at the PuneRuby forum has been a great success. Participants are from all over the world. What's nice about this course is that anyone can join anytime and go thro' the topics at their own pace. There's always a live instructor to help you out with your problems.

The entire Learning Ruby course is now available online here.

Generate RSS Feed

2006-07-15T06:12:00.000+05:30

Neha Gupta has submitted this Ruby code snippet:

xml.rss(:class => "Recipe", :version => "x.x", :xmlns
=> "www.codewalla.com") do
xml.channel do
@Recipes = Recipe.find_all
xml.title("List of Recipes  -- Total ", Recipe.count,
" recipes")
xml.link
xml.description
xml.RecipesAuthor("CodeWalla")
@Recipes.each do |item|
xml.item do
xml.Title(item.title)
xml.link
xml.author("CodeWalla")
xml.desciption(item.description)
xml.date(item.date)
xml.category(item.category.name)
end
end
end
end

The above code is made to generate a rss feed of a particular table from a database. Here, Recipe is a table name and item is the variable in m used to store one recipe temporarily, to display its contents. This code needs to be stored in .rxml file.
Eg: D:/Copy of rails/cookbook/app/views/actor/index.rxml

It can be invoked by:
http://localhost:3000/actor/index.rxml

The output of the code is:

<rss xmlns="www.codewalla.com" version="x.x" class="Recipe">
  <channel>
    <title>List of Recipes  -- Total 4 recipes</title>
    <link/>
    <description/>
    <RecipesAuthor>CodeWalla</RecipesAuthor>
    <item>
      <Title>codewal;l</Title>
      <link/>
      <author>CodeWalla</author>
      <desciption></desciption>
      <date></date>
      <category>Dessert</category>
    </item>
    <item>
      <Title>bbbbbbbbbbbbbb</Title>
      <link/>
      <author>CodeWalla</author>
      <desciption>bbbbbbbbbbbbbb</desciption>
      <date>2006-05-04</date>
      <category>Starters</category>
    </item>
    <item>
      <Title>dsfhsjdflk</Title>
      <link/>
      <author>CodeWalla</author>
      <desciption>;kkb;k</desciption>
      <date>2006-05-04</date>
      <category>Starters</category>
    </item>
    <item>
      <Title>Ice Tea</Title>
      <link/>
      <author>CodeWalla</author>
      <desciption>Good !!!</desciption>
      <date>2006-05-04</date>
      <category>Dessert</category>
    </item>
  </channel>
</rss>

Kindly comment on this code.

Technorati Tags: Generate RSS Feed
Blogs linking to this article

July 2006 PuneRuby meet

2006-07-14T10:01:00.000+05:30

The PuneRuby meet is fixed for this Sunday, 16th July 2006 at 17.00 hrs. The venue, as usual, is SICSR, Model Colony, Pune. The speakers are:

a. Shashank Date - President of Reevik Inc, Kansas, USA. Has an overall experience of 19 years in IT. A known name in the Ruby world, one of the programmers of the Ruby's one-click installer, and is one of the early adopters of Rails.

b. Dibya Prakash

Anyone else interested in speaking kindly let me know asap, the topic and your background.

Technorati Tags: July 2006 PuneRuby meet
Blogs linking to this article

Validation in Rails

2006-07-13T15:16:00.000+05:30

Let's try our hand at some validation. No participant should be allowed in the database if it has an empty text field or an invalid URL for the blog_url. So, where do we put the validation? The model layer is the gatekeeper between the world of code and the database. Nothing to do with our application comes out of the database or gets stored back into the database that doesn't first go through the model.

This makes it an ideal place to put all validation; it doesn't matter whether the data comes from a form or from some programmatic manipulation in our application. If the model checks it before writing to the database, then the database will be protected from bad data.

Let's look at the source code of the model class (in app/models/participant.rb).

class Participant < ActiveRecord::Base
end

Not much to it, is there? All of the database mapping, creating, updating, searching, and so on is done in the parent class (ActiveRecord::Base, a part of Rails). Because of the joys of inheritance, our Participant class gets all of that functionality automatically.

Let's start by validating that the text fields all contain something before a row is written to the database. We do this by adding some code to the existing model, as follows:

class Participant < ActiveRecord::Base
  validates_presence_of :name, :city, :blog_url
end

The validates_presence_of( ) method is a standard Rails validator. It checks that a given field, or set of fields, is present and its contents are not empty. The screen shot, shows what happens if we try to submit a new product with none of the fields filled in. It's pretty impressive: the fields with errors are highlighted, and the errors are summarized in a nice list at the top of the form. Not bad for one line of code. You might also have noticed that after editing the participant.rb file you didn't have to restart the application to test your changes. Rails notices that the files have been changed and reloads them into the application. This is a tremendous productivity boost when developing.

We also want to make sure that each partcipant has a unique blog_url. One more line in the Participant model will do this. The uniqueness validation will perform a simple check to ensure that no other row in the participants table has the same blog_url as the row we're about to save.
validates_uniqueness_of :blog_url

First Post | Previous | Next

Technorati Tags: Validation in Rails
Blogs linking to this article

Adding a Missing Column

2006-07-13T05:11:00.000+05:30

Let's say we decide that our participants table needs an additional column for storing the participant's blog URL. This means we'll need to add a column to the database table, and we'll need to make sure that the various maintenance pages are updated to add support for this new column. Let's alter the file db/create.sql, adding the blog_url column. Let's save this file as create2.sql as shown here:

drop table if exists participants;
create table participants (
  id int not null auto_increment,
  name varchar(100) not null,
  city text not null,
  blog_url varchar(200) not null,
  primary key (id)
);

When I first created this file, I added a drop table command at the top of it. This now allows us to create a new (empty) schema instance with the command:
c:/rails/work/student>mysql student <db/create2.sql

Obviously, this approach only works if there isn't important data already in the database table (as dropping the table wipes out the data it contains). That's fine during development, but in production we'd need to be careful.

The schema has changed, so our scaffold code is now out-of-date. As we've made no changes to the code, it's safe to regenerate it. Notice that the generate script prompts us when it's about to overwrite a file. We type Y to indicate that it can overwrite all files. The command is:
c:/rails/work/student>ruby script/generate scaffold Participant Admin

You can now enter the new data and the screen should look like this.

First Post | Previous | Next

Technorati Tags: Adding a Missing Column
Blogs linking to this article

Configuring the Application

2006-07-12T13:22:00.000+05:30

Rails uses a flat file located in config/database.yml to store the information on how to connect to the database. This file should be edited to look like this:

# MySQL (default setup).  Versions 4.1 and 5.0 are recommended.
#
# Install the MySQL driver:
#   gem install mysql
# On MacOS X:
#   gem install mysql -- --include=/usr/local/lib
# On Windows:
#   There is no gem for Windows.  Install mysql.so from RubyForApache.
#   http://rubyforge.org/projects/rubyforapache
#
# And be sure to use new-style password hashing:
#   http://dev.mysql.com/doc/refman/5.0/en/old-client.html
development:
  adapter: mysql
  database: student
  username:
  password:
  host: localhost

# Warning: The database defined as 'test' will be erased and
# re-generated from your development database when you run 'rake'.
# Do not set this db to the same as development or production.
test:
  adapter: mysql
  database: student_test
  username: root
  password:
  host: localhost

production:
  adapter: mysql
  database: student_production
  username: root
  password:
  host: localhost

Now let us write the maintenance application. In a command window type:
c:/rails/work/student>ruby script/generate scaffold Participant Admin

That single command has written a basic maintenance application. The Participant parameter told the command the name of the model we want, and the Admin parameter specifies the name of the controller. Let's try our application. First, we'll start a local WEBrick-based web server, supplied with Rails. Let's connect to it. Remember, the URL we give to our browser contains both the port number (3000) and the name of the controller in lowercase (admin) ie. http://localhost:3000/admin

It's showing us a list of participants, and there aren't any participants. Let's remedy that. Click the New participant link, and a form should appear. Fill in the details and click on the Create button, you should see the new participant in the list. See the screenshot. The User Interface is not good, but it works. We can show this to our client for his/her approval. The client can play with the other links (showing details, editing existing participants etc.).

Rails Scaffolds
A Rails scaffold is an autogenerated framework for manipulating a model. When we run the generator, we tell it that we want a scaffold for a particular model (which it creates) and that we want to access it through a given controller (which it also creates). In Rails, a model is automatically mapped to a database table whose name is the plural form of the model's class. In our case, we asked for a model called Participant, so Rails associated it with the table called participants. And how did it find that table? We told it where to look when we set up the development entry in config/database.yml. When we started the application, the model examined the table in the database, worked out what columns it had, and created mappings between the database data and Ruby objects. We created the participant maintenance scaffolding in the Admin controller, which is why the URL that accesses it has admin at the start of its path. The scaffold is the starting point of an application, not a finished application. And we're about to make use of that fact as we move on to the next iteration in our project.

First Post | Previous | Next

Technorati Tags: Configuring the Application
Blogs linking to this article

Rails and Database Tables

2006-07-11T11:10:00.000+05:30

We shall now create a web interface that lets us maintain a student database - create new student records, edit existing student records, delete unwanted ones, and so on. We'll develop this application in small iterations. We'll start off by creating a new Rails application. This is where we'll be doing all our work. Next, we'll create a database to hold our information.

Open a command window and navigate to our folder 'work' where the path on my machine is c:/rails/work Switch to the work folder and use the rails command to create an application called student, as follows.
c:/rails/work>rails student

Create the database student
In a command window type:
c:/rails/work/student>mysql -uroot
You should now get a mysql prompt. Next at the mysql prompt, type as follows:
mysql>create database student;
It will respond with:
Query OK, 1 row affected (0.00 sec)
Next, on the mysql prompt, type:
mysql>grant all on student.* to 'root'@'localhost';
Then type:
mysql>exit

Let's write the Data Definition Language (DDL) for creating the student table in MySQL. Your application student has a sub folder db where we shall store this file create.sql

drop table if exists participants;
create table participants (
  id int not null auto_increment,
  name varchar(100) not null,
  city text not null,
  primary key (id)
);

Rails assumes that every table it handles has as its primary key an integer column called id Internally, Rails uses the value in this column to keep track of the data it has loaded from the database and to link between data in different tables.

Now use the mysql client to execute the DDL and create the table in our student database. Type:
c:/rails/work/student>mysql student <db/create.sql
This would have created our participants table.

Rails Naming Convention
Rails assumes that:

database table names, like variable names, have lowercase letters and underscores between the words.
table names are always plural.
files are named in lowercase with underscores.

Rails uses this knowledge of naming conventions to convert names automatically. For example, your application might contain a model class that handles line items. You'd define the class using the Ruby naming convention, calling it LineItem. From this name, Rails would automatically deduce the following.

That the corresponding database table will be called line_items. That's the class name, converted to lowercase, with underscores between the words and pluralized.
Rails would also know to look for the class definition in a file called line_item.rb (in the app/models directory).

Rails controllers have additional naming conventions. If our application has a store controller, then the following happens.

Rails assumes the class is called StoreController and that it's in a file named store_controller.rb in the app/controllers directory.
It also assumes there's a helper module named StoreHelper in the file store_helper.rb located in the app/helpers directory.
It will look for view templates for this controller in the app/views/store directory.
It will by default take the output of these views and wrap them in the layout template contained in store.rhtml or store.rxml in the directory app/views/layouts.

Rails helps by giving you most of the configuration for free if you follow the standard conventions.

First Post | Previous | Next

Technorati Tags: Rails and Database Tables
Blogs linking to this article

Hello, PuneRuby from Rails

2006-07-09T14:26:00.000+05:30

Rails being an MVC framework, accepts incoming requests from a browser, decodes the request to find a controller, and calls an action method in that controller. The controller then invokes a particular view to display the results back to the user. Rails takes care of most of the internal plumbing that links all these things together. To write our simple Hello, PuneRuby application, we need code for a controller and a view. We don't need code for a model, as we're not dealing with any data.

Let's use a generator script to create a new controller for our application. This command is called generate, and it lives in the script subdirectory of the demo folder we created. Let's create a controller called Say as follows:
c:/rails/work/demo>ruby script/generate controller Say
The source file we'll be interested in is the controller. You'll find the file say_controller.rb in the folder:
app/controllers/say_controller.rb. Let's have a look at it.

class SayController < ApplicationController
end

SayController is an empty class that inherits from ApplicationController, so it automatically gets all the default controller behavior. We need to add some code to have our controller handle the incoming request. What does this code have to do? For now, it'll do nothing - we simply need an empty action method. Let's add an action called hello to our say controller. Adding a hello action means creating a method called hello in the class SayController. A controller's job is to set up things so that the view knows what to display. In our first application, there's nothing to set up, so an empty action will work fine. Modify say_controller.rb as follow:

class SayController < ApplicationController
 def hello
 end
end

Now let's try calling it. Find a browser window, and navigate to the URL:
http://localhost:3000/say/hello.
You will see in your browser, a message saying - "Template is Missing." This happens because we created the controller class and the action method, but we haven't told Rails what to display.

By default, Rails looks for templates in a file with the same name as the action it's handling. In our case, that means we need to create a file called hello.rhtml in the folder:
app/views/say/hello.rhtml as follow:

<html>
  <head>
    <title>Hello, PuneRuby</title>
  </head>
  <body>
    <h1>Hello from PuneRuby!</h1>
  </body>
</html>

Save the file hello.rhtml, and refresh your browser window. You should see it display our friendly greeting. Notice that we didn't have to restart the application to see the update. During development, Rails automatically integrates changes into the running application as you save files.

The .rhtml suffix tells Rails to expand the content in the file using a system called ERb (for Embedded Ruby). ERb is a filter that takes an .rhtml file and outputs a transformed version. The output file is often HTML in Rails, but it can be anything. Normal content is passed through without being changed. However, content between <%= and %> is interpreted as Ruby code and executed. The result of that execution is converted into a string, and that value is substituted into the
file in place of the <%=...%> sequence. Here's the modified hello1.rhtml file. In addition, stuff in rhtml between <% and %> (without an equals sign) is interpreted as Ruby code that is executed with no substitution back into the output. The interesting thing about this kind of processing, though, is that it can be intermixed with non-Ruby code. Refresh your browser to see the result.

Let's see how we can link two pages. Add a bye method to the file say_controller.rb as follows:

class SayController < ApplicationController
  def hello
  end
  def bye
  end
end

and create the relevant bye.rhtml file as follows:

<html>
  <head>
    <title>Bye for now</title>
  </head>
  <body>
    <h1>Bye for now</h1>
  </body>
</html>

Fire up your browser again, but this time point to the new view using the URL
http://localhost:3000/say/bye.

Now we need to link the two screens together. We'll put a link on the hello screen that takes us to the bye screen, and vice versa. For now we'll use hyperlinks. Rails comes with a bunch of helper methods that can be used in view templates. Here, we'll use the helper method link_to( ), which creates a hyperlink to an action. The file hello2.rhtml shows this:

<html>
  <head>
    <title>Hello, PuneRuby</title>
  </head>
  <body>
    <h1>Hello from PuneRuby</h1>
  <!-- code added for third part of tutorial -->
  <br />
  <br />
  <%= Time.now %>
  <br />
  <p>
   Time to say
   <%= link_to "Bye", :action => "bye" %>
  </p>
  <!-- code added for third part of tutorial -->
  </body>
</html>

There's a link_to( ) call within an ERb <%=...%> sequence. This creates a link to a URL that will invoke the bye( ) action. The first parameter in the call to link_to( ) is the text to be displayed in the hyperlink, and the next parameter tells Rails to generate the link to the bye action. As we don't specify a controller, the current one will be used.

Assignment: Create a .rhtml page that links to our page hello2.rhtml Post your solution as comment to this blog post.

First Post | Previous | Next

Technorati Tags: Hello, PuneRuby from Rails
Blogs linking to this article

Verifying Rails Installation

2006-07-04T06:22:00.000+05:30

When you install the Rails framework, you also get a new command-line tool, rails, which is used to construct each new Rails application that you write. The rails command creates the right directory structure for you and populates it with some standard Rails code.

We shall create a very small web application to verify our Rails installation.

Open a command window and navigate to a place in your filesystem where you would want to create your application's directory structure. I am creating it in a folder called work and the path on my machine is c:/rails/work Switch to the work folder and use the rails command to create an application called demo, as follows.
c:/rails/work>rails demo

The command has created a directory named demo. Within the demo folder there are many other folders and files created for you. Amongst all of this, you will find a folder called script, that contains some utility scripts that we will be using as we develop our application. For now, we will use the server script that starts a stand-alone web server that can run our newly created Rail application under WEBrick (this is a pure-Ruby web server that comes along with Ruby). So type the command:
c:/rails/work/demo>ruby script/server

We have just started a web server at port 3000. We can now access the application by pointing a browser at http://localhost:3000
You can press control-C to stop WEBrick.

First Post | Previous | Next

Technorati Tags: Verifying Rails Installation
Blogs linking to this article

Ruby on Rails Installation

2006-07-02T13:06:00.000+05:30

Armed with the elementary knowledge of Ruby gained so far, I am now going to explore Ruby on Rails. Rails is a full-stack, open-source web framework (support structure) in Ruby, that closely follows the Model View Controller (MVC) architecture for writing real-world applications (Rails applications are written in Ruby) with less code and no cumbersome XML configuration files. Simply put, Rails is an open source Ruby framework for developing database-backed web applications.

To install Ruby on Rails on Windows, we need to do the following:

Install Ruby 1.8.2 which we have already done.
Check whether you have RubyGems installed by typing gem --version in a command window. We should have this too.
Now we'll use RubyGems to install Rails and a few things that Rails needs. Ensure that your internet connection is active. In a command window, type gem install rails --include-dependencies
Congratulations! You are now on Rails.
There's one more step you have to perform before you can start development. Rails works with DB2, MySQL, Oracle, Postgres, SQL Server and SQLite databases. For all but MySQL, you will need to install a database driver, a library that Rails can use to connect to and use your database engine. Rails come with a built-in driver (written in pure Ruby) for MySQL databases. We shall use MySQL 4.1.8 and the installation instructions are in the file mysqlsetup.doc.
To update our Rails is simple. In a Command window type: gem update rails RubyGems will automatically update your Rails installation.

I would like all the 42 participants to comment on this post, after they have installed Rails.

First Post | Previous | Next

Technorati Tags: Ruby on Rails Installation
Blogs linking to this article

Ruby Miscellanea

2006-07-02T10:34:00.000+05:30

This is a Work-In-Progress and will cover Ruby Miscellanea topics but relevant to Ruby on Rails.

More on Constants:
- Constants defined within a class or module may be accessed anywhere within the class or module.
- Outside the class or module, they may be accessed using the scope operator, :: prefixed by an expression that returns the appropriate class or module.
- Constants defined outside any class or module may be accessed as it is or by using the scope operator with no prefix.
- Constants may not be defined in methods.
- Constants may be added to existing classes and modules from the outside by using the class or module name and the scope operator before the constant name. The program Const.rb shows all of this:
```
OUTER_CONST = 99

class Const
 def get_const
  CONST
 end
 CONST = OUTER_CONST + 1
end

puts Const.new.get_const
puts Const::CONST
puts ::OUTER_CONST
puts Const::NEW_CONST = 123
```

Modules
Modules are similar to classes in that they hold a collection of methods, constants, and other module and class definitions. Unlike classes, you cannot create objects based on modules.

Modules serve two purposes:

First they act as namespace, letting you define methods whose names will not clash with those defined elsewhere. The examples MyTrig.rb, MyMoral.rb and UseModule.rb illustrates this.

# MyTrig.rb
module Trig
  PI = 3.1416
  # class methods
  def Trig.sin(x)
    # ...
  end
  def Trig.cos(x)
    # ...
  end
end

# MyMoral.rb
module Moral
  VERY_BAD = 0
  BAD      = 1
  def Moral.sin(badness)
    # ...
  end
end

# UseModule.rb
require 'MyTrig'
require 'MyMoral'
y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

Second, they allow you to share functionality between classes - if a class mixes in a module, that module’s instance methods become available as if they had been defined in the class. They get mixed in. The program Mixins.rb illustrates this:

# Mixins.rb
module D
 def initialize(name)
    @name =name
 end
  def to_s
  @name
 end
end

module Debug
  include D
 # Methods that act as queries are often
 # named with a trailing ?
 def who_am_i?
  "#{self.class.name} (\##{self.object_id}): #{self.to_s}"
 end
end

class Phonograph
 # the include statement simply makes a reference to a named module
 # If that module is in a separate file, use require to drag the file in
 # before using include
 include Debug
 # ...
end

class EightTrack
 include Debug
 # ...
end

ph = Phonograph.new("West End Blues")
et = EightTrack.new("Real Pillow")
puts ph.who_am_i?
puts et.who_am_i?

Symbols
A symbol looks like a variable name but it’s prefixed with a colon. Examples: :action, :line_items. You can think of symbols as string literals that are magically turned into constants. Alternatively, you can consider the colon to mean "thing named" so :id is "the thing named id." You can also think of :id as meaning the name of the variable id, and plain id as meaning the value of the variable.

First Post | Previous | Next

Technorati Tags: Ruby Miscellanea
Blogs linking to this article

Ruby FAQ

2006-07-01T08:34:00.000+05:30

What do you mean by "Ruby is a Dynamic programming language".

In computer science, a dynamic programming language is a kind of programming language in which programs can change their structure as they run: functions may be introduced or removed, new classes of objects may be created, new modules may appear. Refer here for more details.

Can we delete an entry in the middle and shift the remaining entries, in an array?

The delete method of an array can do that, for example:

a = ["a", "b", "b", "c"]
a.delete("b")

The contents of array are now "a" and "c".

Does Ruby have associative arrays like awk?

Hashes (sometimes known as associative arrays, maps or dictionaries) are available in Ruby.

How is memory managed for Strings in Ruby? Is there a separate pool for Strings?

Strings are objects of class String. The String class has more than 75 standard methods. If you refer to Ruby User's Guide, it says that "we do not have to consider the space occupied by a string. We are free from all memory management."

Does Ruby allow us to write functions that can accept variable number of parameters?

Yes. See this example:

def print_nums(*numbers)

end

Can we have an anonymous class in Ruby?

Yes. Refer page 382 of the second edition of the book Programming Ruby, by Dave Thomas

Does Ruby have Multiple Inheritance?

Ruby uses modules to implement mix-ins that simulate multiple inheritance.

Does Ruby allow Object Serialization?

Java features the ability to serialize objects, letting you store them somewhere and reconstitute them when needed. Ruby calls this kind of serialization marshaling. Saving an object and some or all of its components is done using the method Marshal.dump. Later on you can reconstitute the object using Marshal.load. Ruby uses marshaling to store session data.

Java and Ruby Similarities:

As with Java, in Ruby...

memory is managed for you via a garbage collector.
there’s public, private, and protected methods.
you’ve got embedded doc tools (Ruby’s is called RDoc). The docs generated by rdoc look very similar to those generated by javadoc. RDoc can produce fairly good content even if the source contains no comments.

Java and Ruby Differences:

Unlike Java, in Ruby...

you don’t need to compile your code. You just run it directly.
there’s different GUI toolkits. Ruby users can try WxRuby,
FXRuby, or the bundled-in Ruby Tk for example.
you use the end keyword after defining things like classes, instead of having to put braces around blocks of code.
you have require instead of import.
all member variables are private. From the outside, you access everything via methods.
parentheses in method calls are usually optional and often omitted.
everything is an object, including numbers like 2 and 3.14159. Classes are objects! For example, Array is a constant name that is bound to the Array class object. To create a new object, we call new on the class object as in a = Array.new
there are no primitives or data types
variable names are just labels (not objects). They don’t have a type associated with them.
there’s no type declarations. You just assign to new variable names as-needed and they just “spring up” (i.e. a = [1,2,3] rather than int[] a = {1,2,3};).
it’s foo = Foo.new( "hi") instead of foo = new Foo( "hi" ).
the constructor is always named “initialize” instead of the name of the class.
you have “mixin’s” instead of interfaces.
YAML tends to be favored over XML.
it’s nil instead of null. Also, nil is a normal object; you can never get a null pointer error!
there is no method overloading.
it's much more common to put many classes in the same file.

This is a work-in-progress.

First Post | Previous | Next

Technorati Tags: Ruby FAQ
Blogs linking to this article

Writing our own Class

2006-06-30T10:42:00.000+05:30

A class is a combination of state (for example, the quantity and the product id) and methods that use the state.

The Object is the parent class of all classes in Ruby. Its methods are therefore available to all objects unless explicitly overridden.

Let's write our own class - MotorCycle.rb.

class MotorCycle
  def initialize(make, color)
    # Instance variables
    @make = make
    @color = color
    end
  def startEngine
    if (@engineState)
      puts 'Engine Running'
    else
      @engineState = true
      puts 'Engine Idle'
    end
  end
  def dispAttr
    puts 'Color of MotorCycle is ' + @color
    puts 'Make  of MotorCycle is ' + @make
  end
  m = MotorCycle.new('Yamaha', 'red')
  m.startEngine
  m.dispAttr
  m.startEngine
end

Read this very carefully, it's a brain bender! Classes in Ruby are first-class objects - each is an instance of class Class. When a new class is defined (typically using class Name ... end), an object of type Class is created and assigned to a constant (Name. in this case). When Name.new is called to create a new object, the new instance method in Class is run by default, which in turn invokes allocate to allocate memory for the object, before finally calling the new object's initialize method.

A class's instance methods are public by default; anyone can call them. Let's refer to the program ClassAccess.rb below. The private directive is the strictest; private methods can only be called from within the same instance. Protected methods can be called in the same instance and by other instances of the same class and its subclasses.

class ClassAccess
 def m1   # this method is public
  end
 protected
 def m2   # this method is protected
 end
 private
 def m3   # this method is private
 end
end

Instance variables are not directly accessible outside the class. To make them available, Ruby provides accessor methods that return their values. The program Accessor.rb illustrates the same.

# Accessor.rb
# First without accessor methods
class Song
 def initialize(name, artist)
    @name     = name
    @artist   = artist
 end
 def name
  @name
 end
 def artist
  @artist
 end
end

song = Song.new("Brazil", "Ricky Martin")
puts song.name
puts song.artist

# Now, with accessor methods
class Song
 def initialize(name, artist)
    @name     = name
    @artist   = artist
 end
  # the instance variable @name and @artist will
  # be automatically created below
  attr_reader :name, :artist # create reader only
 # For creating reader and writer methods
 # attr_accessor :name 
 # For creating writer methods
 # attr_writer :name 

end

song = Song.new("Brazil", "Ricky Martin")
puts song.name
puts song.artist

There are many classes and modules (more on this later) built into the standard Ruby language. They are available to every Ruby program automatically; no require is required. Some built-in classes are Array, Bignum, Class, Dir, Exception, File, Fixnum, Float, Integer, IO, Module, Numeric, Object, Range, String, Thread, Time. Some built-in Modules are Comparable, Enumerable, GC, Kernel, Math. The following Class Hierarchy is informative.

Inheritance allows you to create a class that is a refinement or specialization of another class. Refer program Inherit.rb.

class GF
 def initialize
  puts 'In GF class'
 end
 def gfmethod
  puts 'GF method call'
 end
end

# class F sub-class of GF
class F < GF
 def initialize
  puts 'In F class'
 end
end

# class S sub-class of F
class S < F
 def initialize
  puts 'In S class'
 end
son = S.new
son.gfmethod
end

First Post | Previous | Next

Technorati Tags: Writing our own Class
Blogs linking to this article

Reading from / Writing to Text files

2006-06-29T08:24:00.000+05:30

Let's look at how we can read / write to a text file with the help of a simple program ReadWrite.rb.

# Open and read from a text file
File.open('Constructs.rb', 'r') do |f1|
 while line = f1.gets
  puts line
 end
end

# Create a new file and write to it
File.open('Test.rb', 'w') do |f2|
 # use "" for two lines of text
 f2.puts "Created by Satish\nThank God!"
end

The File.open method can open the file in different modes like 'r' Read-only, starts at beginning of file (default); 'r+' Read/Write, starts at beginning of file; 'w' Write-only, truncates existing file to zero length or creates a new file for writing. Please check the online documentation for a full list of modes available. File.open opens a new File if there is no associated block. If the optional block is given, it will be passed file as an argument, and the file will automatically be closed when the block terminates.

Assignment: Write a Ruby program (call it SwapContents.rb) to do the following. Take two text files say A and B. The program should swap the contents of A and B ie. after the program is executed, A should contain B's contents and B should contains A's. Post your program as a comment to this post.

First Post | Previous | Next

Technorati Tags: Reading from / Writing to Text files
Blogs linking to this article

Own methods in Ruby

2006-06-29T06:16:00.000+05:30

Let's look at writing one's own methods in Ruby with the help of a simple program MyMethods.rb.

# A simple method
def hello
  puts 'Hello'
end
#use the method
hello

# Method with an argument - 1
def hello1(name)
  puts 'Hello ' + name
  return 'success'
end
puts(hello1('satish'))

# Method with an argument - 2
def hello1 name2
  puts 'Hello ' + name2
  return 'success'
end
puts(hello1 'satish')

First Post | Previous | Next

Technorati Tags: Own methods in Ruby
Blogs linking to this article

Arrays in Ruby

2006-06-28T15:15:00.000+05:30

An array is just a list in your computer. Every slot in the list acts like a variable: you can see what object a particular slot points to, and you can make it point to a different object. Arrays are best explained by the following example Arrays.rb.

# Arrays

# Empty array
var1 = []
# Array index starts from 0
puts var1[0]

# an array holding a single number
var2 = [5]
puts var2[0]

# an array holding two strings
var3 = ['Hello', 'Goodbye']
puts var3[0]
puts var3[2]

flavour = 'mango'
# an array whose elements are pointing
# to three objects - a float, a string and an array
var4 = [80.5, flavour, [true, false]]
puts var4[2]

name = ['Satish', 'Talim', 'Ruby', 'Java']
puts name[0]
puts name[1]
puts name[2]
puts name[3]
# the next one outputs nil
# nil is Ruby's way of saying nothing
puts name[4]
# we can add more elements too
name[4] = 'Pune'
puts name[4]
# we can add anything!
name[5] = 4.33
puts name[5]
# we can add an array to an array
name[6] = [1, 2, 3]
puts name[6]

# some methods on arrays
newarr = [45, 23, 1, 90]
puts newarr.sort
puts newarr.length

# method each (iterator) - extracts each element into lang
languages = ['Pune', 'Mumbai', 'Bangalore']

languages.each do |lang|
  puts 'I love ' + lang + '!'
  puts 'Don\'t you?'
end

The method each allows us to do something (whatever we want) to each object the array points to. In the example, we are able to go through each object in the array without using any numbers.

First Post | Previous | Next

Technorati Tags: Arrays in Ruby
Blogs linking to this article

Some Methods in Ruby

2006-06-28T10:09:00.000+05:30

Let us explore some methods in Ruby. So far we had seen a method like puts that writes to the screen. How does one accept user input? For this gets and chomp are useful. The example (Methods.rb) below illustrates the same.

# gets and chomp
puts "In which city do you stay?"
STDOUT.flush
city = gets.chomp
puts "The city is " + city

chomp is a string method and gets retrieves only strings from your keyboard. You must have realised that gets returns a string and a '\n' character, while chomp removes this '\n'.

There are many methods in the String class (you don't have to memorize them all; you can look up the documentation) like the reverse that gives a backwards version of a string (reverse does not change the original string). length that tells us the number of characters (including spaces) in the string. upcase changes every lowercase letter to uppercase, and downcase changes every uppercase letter to lowercase. swapcase switches the case of every letter in the string, and finally, capitalize is just like downcase, except that it switches the first character to uppercase (if it is a letter).

More on methods: If objects (such as strings, integers and floats) are the nouns in Ruby language, then methods are the verbs. Every method needs an object. It's usually easy to tell which object is performing the method: it's what comes right before the dot. Sometimes, though, it's not quite as obvious. When we are using puts, gets - where are their objects? In Ruby, the implicit object is whatever object you happen to be in. But we don't even know how to be in an object yet; we've always been inside a special object Ruby has created for us that represents the whole program. You can see always see what object you are in by using the special variable self.

First Post | Previous | Next

Technorati Tags: Some Methods in Ruby
Blogs linking to this article

Simple Constructs in Ruby

2006-06-28T06:46:00.000+05:30

Today, we shall explore some very simple constructs available in Ruby. The example below (Constructs.rb) illustrates the if else end construct.

# if else end
var = 5
if var > 4
  puts "Variable is greater than 4"
  puts "I can have multiple statements here"
  if var == 5
      puts "Nested if else possible"
  else
      puts "Too cool"
  end
else
    puts "Variable is not greater than 5"
    puts "I can have multiple statements here"
end

An example of using elsif is there in the program ElsIfEx.rb

Some common conditional operators are: ==, != >=, <=, >, <

Loops like the while are available. Again, the example below illustrates the same.

# Loops
var = 0
while var < 10
    puts var.to_s
  var += 1
end

I shall talk about another construct the do end when we discuss arrays.

First Post | Previous | Next

Technorati Tags: Simple Constructs in Ruby
Blogs linking to this article

Strings in Ruby

2006-06-27T10:35:00.000+05:30

Let us explore Strings in Ruby. We refer to a group of letters in a program as strings. Strings can have punctuation, digits, symbols, and spaces in them...more than just letters. '' does not have anything in it at all; we call that an empty string. Here's the program RubyStrings.rb

=begin
 Ruby Strings
=end

puts "Hello World"
# Can use " or ' for Strings, but ' is more efficient
puts 'Hello World'
# String concatenation
puts 'I like' + ' Ruby'
# Escape sequence
puts 'It\'s my Ruby'
# New here, displays the string three times
puts 'Hello' * 3
# Defining a constant
PI = 3.1416
puts PI
# Defining a local variable
myString = 'I love my city, Pune'
puts myString
=begin
 Conversions
 .to_i, .to_f, .to_s
=end
var1 = 5;
var2 = '2'
puts var1 + var2.to_i

Questions asked by the participants:
1. Sharif Kazi - Please explain how memory is managed for Strings in Ruby? Is there a separate pool for Strings?
Answer: Strings are objects of class String. The String class has more than 75 standard methods. If you refer to Ruby User's Guide, it says that "we do not have to consider the space occupied by a string. We are free from all memory management."

2. Anish - It's to be noted that any given variable can at different times hold references to objects of many different types. - Does that mean a variable of type x can hold reference to the variable of type b without direct relation (inheritance) between them?
Answer: Please go thro' the code in the program DiffObjects.rb We can assign an object to a variable. Also, we can reassign a different object to that variable. In fact, variables can point to just about anything...except other variables. So in the program, when we tried var2 = var1, it really pointed to 8 instead. Then with var1 = 'eight', we had var1 point to the string 'eight', but since var2 was never really pointing at var1, it stays pointing at the number 8.

3. Deepali - Do we have something like print of Java?
Answer: Yes, we do have that in Ruby. Write a Ruby program that has this statement and check the output.
STDOUT.print("This is a string")

First Post | Previous | Next

Technorati Tags: Strings in Ruby
Blogs linking to this article

Numbers in Ruby

2006-06-27T09:49:00.000+05:30

Let's play with Numbers. In Ruby, numbers without decimal points are called integers, and numbers with decimal points are usually called floating-point numbers or, more simply, floats. Here's the program RubyNumbers.rb

=begin
 Ruby Numbers
 Usual operators:
 + addition
 - subtraction
 * multiplication
 / division
=end

puts 1 + 2
puts 2 * 3
# Integer division
# When you do arithmetic with integers, you'll get integer answers
puts 3 / 2
puts 10 - 11
puts 1.5 / 2.6

Questions asked by the participants:
1. Jatinder Singh - How do I get the integer result for the following operation (the desired output is 2) - puts 5.5/2
Answer: Try this -
num = 5.5 /2
puts num
puts num.to_int

First Post | Previous | Next

Technorati Tags: Numbers in Ruby
Blogs linking to this article

Names in Ruby

2006-06-27T09:13:00.000+05:30

Now, let us look at Names in Ruby.

Names - Ruby names are used to refer to constants, variables, methods, classes, and modules (more of this later). The first character of a name helps Ruby to distinguish its intended use. Certain names, are reserved words and should not be used as variable, method, class, or module names. Lowercase letter means the characters ''a'' though ''z'', as well as ''_'', the underscore. Uppercase letter means ''A'' though ''Z,'' and digit means ''0'' through ''9.'' A name is an uppercase letter, lowercase letter, or an underscore, followed by Name characters: any combination of upper- and lowercase letters, underscore and digits.
Variables - Variables in Ruby can contain data of any type. You can use variables in your Ruby programs without any declarations. Variable name itself denotes its scope (local, global, instance, etc.).
1. A local variable name consists of a lowercase letter followed by name characters (sunil, myCount, _z, hit_and_run).
2. An instance variable name starts with an ''at'' sign (''@'') followed by an upper- or lowercase letter, optionally followed by name characters (@sign, @_, @Counter).
3. A class variable name starts with two ''at'' signs (''@@'') followed by an upper- or lowercase letter. optionally followed by name characters (@@sign, @@_, @@Counter).
4. A constant name starts with an uppercase letter followed by name characters. Class names and module names are constants, and follow the constant naming conventions. By convention, constant variables are normally spelled using uppercase letters and underscores throughout (module MyMath, PI=3.1416, class MyPune).
5. Global variables start with a dollar sign (''$'') followed by name characters. A global variable name can be formed using ''$-'' followed by any single character ($counter, $COUNTER, $-x).
Method names should begin with a lowercase letter. ''?'' and ''!'' are the only weird characters allowed as method name suffixes (More on this later).

The Ruby convention is to use underscores to separate words in a multiword method or variable name. For Class names, module names and constants the convention is to use capitalization, rather than underscores, to distinguish the start of words within the name.

It's to be noted that any given variable can at different times hold references to objects of many different types. A Ruby constant is also a reference to an object. Constants are created when they are first assigned to (normally in a class or module definition; they should not be defined in a method - more of this later). Ruby lets you alter the value of a constant, although this will generate a warning message. Also, variables in Ruby act as "references" to objects which undergo automatic garbage collection.

Questions asked by the participants:
1. Shantanu - If I declare a variable 'x', and later on I want to make it global, can I do that?

2. Jatinder Singh - What is the scope of a global variable? Can I access them between two different files? A lot of relevant questions are coming into my mind like, what if a global variable already declared somewhere else is declared again with the same name (shadowing variables?) Also, what is the difference between Constants and Global Variables?

First Post | Previous | Next

Technorati Tags: Names in Ruby
Blogs linking to this article

Some features of Ruby

2006-06-27T08:54:00.000+05:30

Now, let us explore some of the features of Ruby.

Free format
Case sensitive
Comments - Anything following an unquoted #, to the end of the line on which it appears, is ignored by the interpreter. Also, to facilitate large comment blocks, the ruby interpreter also ignores anything between a line starting with "=begin" and another line starting with "=end"
Statement delimiters - Multiple statements on one line must be separated by semicolons, but they are not required at the end of a line; a linefeed is treated like a semicolon. If a line ends with a backslash (\), the linefeed following it is ignored; this allows you to have a single logical line that spans several lines
Documentation - The complete documentation for Ruby is available online here.

First Post | Previous | Next

Technorati Tags: Some features of Ruby
Blogs linking to this article

Ruby Quotes

2006-06-25T11:34:00.000+05:30

Here are some Ruby Quotes to egg us on:

Dave Thomas:

And now, for the first time, I can seriously say that Ruby is ready for the enterprise. The language is stable, the libraries are great, and there is a growing pool of talented and enthusiastic Ruby developers, all rising to the challenge. We see companies such as Amazon and EarthLink using Ruby for both internal- and external-facing projects.

Technorati Tags: Ruby Quotes, Dave Thomas
Blogs linking to this article

First Ruby program

2006-06-24T16:56:00.000+05:30

Let's start our Ruby editor SciTE. To do so, on your windows desktop click on start/Programs/Ruby/Ruby182-15/SciTE Editor. The editor window opens. Press the F8 key to open an output window. Now, click on Options/Open Global Options File and search for 'tabsize'. Edit and make tabsize=2 and indent.size=2. Press Ctrl+S and the Ctrl+W. We are now ready to write our first Ruby program.

OBJECTIVE

Ruby and Rails covered here will give you the grounding you need to understand Rails code and write your own Rails applications.

Create a folder named say rubyprograms on your C:\ We shall store all our programs in this folder. Our first program will display the string "Hello" on the command window and the name of the program will be Hello.rb

All Ruby source files have the .rb file extension. In the left window of SciTE type puts 'Hello' and then click File/Save As... Give the name Hello.rb and store it in your rubyprograms folder. Press F5 to run your program. You should see Hello in the output window on the right.

Note: puts (s in puts stands for string; puts really means put string) simply writes onto the screen whatever comes after it. In Ruby, everything from an integer to a string is considered to be an object. And each object has built in 'methods' which can be used to do various useful things. To use a method, you need to put a dot after the object, then append the method name. Some methods such as puts and gets are available everywhere and don't need to be associated with a specific object. Technically speaking, these methods are provided by Ruby's Kernel module and they are included in all Ruby objects. When you run a Ruby application, an object called main is automatically created and this object provides access to the Kernel methods (Reference: The Little Book of Ruby).

Observe:
(a) Java and C programmers - no main method/function
(b) I am using single quotes around Hello. We can use " or ' for Strings, but ' is more efficient - more on this later
(c) The Ruby standard is to use two spaces for indentation

First Post | Previous | Next

Technorati Tags: First Ruby program
Blogs linking to this article

List of Resources

2006-06-23T10:45:00.000+05:30

Here's a list of resources that we may refer to:

A. Ruby Resources

1. Books/eBooks/Magazines

2. Useful Links

3. Blogs

4. Forums/User Groups

5. Companies in India working in Ruby/Rails

B. Rail Resources
1. Books/eBooks/Magazines
2. Useful Links

Ruby On Rails

First Post | Previous | Next

Technorati Tags: List of Resources
Blogs linking to this article

Know the participants

2006-06-23T08:56:00.000+05:30

I would like you to meet all the participants in this Ruby/Rails training programme.

Gaurav Bagga from Pune and a software professional
Abhijit Paranjpe from Pune and a Java professional
Anil Wadghule from Pune, a cool blogger and about to make a career in the I.T. field
Anish Betawadkar from Pune and a Project Manager with experience in VB, Oracle PL/SQL
Ashish Kulkarni from Stirling, Scotland, a Senior Consultant at SAP For Business Ltd., UK
Ashwini Khanna
Vaidehi Keskar
Deepali Ahirrao from Pune and working at Persistent
Eswar Malla from Visakhapatnam and about to make a career in the I.T. field and shifting to Bangalore soon
Gajendra Pingalkar from Pune and about to enter the I.T. field
Gaurav Kotak from San Francisco, USA, in the process of incubating an eCommernce mashup - GiftLasso.com. Plans to use Ruby for the development
Hemanshu Narsana from Pune about to enter the I.T. field
Jatinder Singh from Pune and worked on Test Automation and Web projects
Jai Porje from Pune working with ECMi Software Pvt Ltd
Dhanashree Angolkar from Pune working with ECMi Software Pvt Ltd
Suhas Nehete
Jincy John from Mumbai currently pursuing MBA(IT) from Symbiosis, Pune
Kaustubh Bhat from Pune and a .NET professional
Manoj Sagar from Ambajogai district Beed and a Java professional working in Aurangabad
Nitin Asati from Pune working on ASP, AJAX
Rajesh Kumar from Bangalore and a software professional
Sachin Joshi from Pune and an experienced User Interface Designer
Sandeep Suryavanshi from Pune and a Java professional
Sandip Deshmane from Pune and a Java professional
Shambhu Sinha from Pune and an experienced Java professional
Shantanu Mahajan from Pune with knowledge of scripting languages
Sharif Kazi from Pune with a background in J2EE
Smita Deshpande from Pune and working with Persistent, with background in Perl
Tejaswini Patwardhan from Pune and a Java professional; scored 95% in SCJP4
Pooja Palan from Mumbai and working with TCS
Vasudev Ram from Pune, an independent software consultant
Yogesh
Vishal Solanke from Aurangabad and works in IXIA Technologies Pvt Ltd
Vikrant Chaudhari from Pune and working with Reevik as a Java developer
Shilpa Waghmare
Nick Audo from Sebago, USA and an I.T. professional
Scot Gardner from Pennsylvania, USA and has been developing web applications in PHP/MySQL for the last 4 years as a hobby
Dave Rose from Cleveland, Ohio, USA and a DBA of a utility billing system for a small division of a local Govt.; 30 years in the programming business
Robert Gremillion from Houston, Texas, USA and an Oracle programmer
Patrick Berkeley from San Fransisco, USA with background in C, HTML, CSS
Zahir Khan from Pune and about to make a career in the I.T. field

It's my sincere request that each one of you post a comment here, letting us know the following:
(a) Your full name
(b) Where you are from
(c) Your technical background

First Post | Previous | Next

Technorati Tags: Know the participants
Blogs linking to this article

Let's get started

2006-06-22T16:00:00.000+05:30

Let's get started.

First, What is Ruby? Ruby is a cross-platform interpreted language which has many features in common with other 'scripting' languages such as Perl and Python. However, its version of object orientation is more thorough than those languages and, in many respects, it has more in common with Smalltalk. In Ruby, everything you manipulate is an object, and the results of those manipulations are themselves objects. The Ruby language was created in 1993 by Yukihiro Matsumoto (commonly known as 'Matz').

27th June @ 8.00 hrs

Remember you need to comment here and say that you have installed Ruby on your PC.

Next, What is Rails? Currently much of the excitement surrounding Ruby can be attributed to a web development framework called Rails - popularly known as 'Ruby On Rails'. Ruby and Rails covered here will give you the grounding you need to understand Rails code and write your own Rails applications.

Today, Download Ruby plus an Editor.The simplest way to get Ruby installed on a PC is by using the Ruby Installer for Windows. Click on ruby182-15.exe This includes the SciTE code editor. Ruby releases with even subversion numbers - 1.6, 1.8, and so on - are stable, public releases. Install Ruby on your PC. After you have installed your Ruby software, the System Environment Variable path is already set to point to the bin folder of Ruby.

Do note that these instruction assume that you are going to use a Windows platform. For other platforms, I would request our participant Shantanu to post his comments on the process.

Ruby is the interpreted language, so you don't have to recompile to execute the program written in Ruby.

Questions asked by the participants:
1. Vikrant Chaudhari - Please explain the statement "Ruby is a Dynamic programming language."
Answer: In computer science, a dynamic programming language is a kind of programming language in which programs can change their structure as they run: functions may be introduced or removed, new classes of objects may be created, new modules may appear. Refer here for more details.

In the next session, we shall start writing Ruby programs.

First Post | Previous | Next

Technorati Tags: Let's get started
Blogs linking to this article

Learn Ruby/Rails with me

2006-06-22T09:37:00.000+05:30

I have been toying with the idea of teaching/learning Ruby/Rails on the net along with some students. Finally, some have agreed and I have decided to give it a go, starting Monday, 26th June 2006.

For those who are interested, you need to do the following:
(a) First, I shall send you all an invite to join the PuneRuby group. It's free.
(b) We shall start learning Ruby/Rails from Monday, 26th June 2006. I shall post everyday something about the same on this blog. You should check this blog atleast once a day and comment about your queries, questions, doubts. I shall answer them here only.
(c) To be able to comment on this blog, you need a blogger account (free).
(d) Go to http://www.blogger.com/start
(e) Click on CREATE YOU BLOG NOW
(f) On the next page, create your account. While doing so, please give your firstname+lastname as Display name. Complete the form.
(g) Kindly do all of this before this Sunday, 25th June 2006.

I assure you it's going to be fun all the way.
If you have any queries, please email me at satish.talim@gmail.com

Assumption: I am assuming that each one of you would be knowing some programming language like C or Java or VB.

Update: 42 people have registered for learning Ruby/Rails with me.

Next Post

Technorati Tags: Learn Ruby/Rails with me
Blogs linking to this article

Web Services on Rails

2006-06-15T15:53:00.000+05:30

O'Reilly have been kind enough to give us a review copy of "Web Services on Rails" by Kevin Marshall. In recent years, web services have become increasingly useful to smaller web site developers. Thanks to standards like SOAP and XML-RPC as well as frameworks such as Ruby on Rails, developers can easily create web service clients and servers with fewer errors. This guide looks at how Ruby on Rails makes building web service clients and servers simple and fun, with plenty of working examples and code details so you can see just how everything works.
ISBN: 0-596-52796-9, 32 pages, $9.99 US, $12.99 CA
O'Reilly Link

Download this file.

Technorati Tags: Web Services on Rails,O'Reilly
Blogs linking to this article

BarCampPune

2006-05-30T08:41:00.000+05:30

BarCampPune on 17th June 2006, is an "unconference" - organized by attendees, for attendees. It's an open, welcoming event for geeks to hang out with wifi and smash their brains together. It's about love and geekery and having a focal point for great ideas.

Attendees are strongly encouraged to give a demo, a session, or help with one. You can help by taking notes on the wiki, blogging the event, helping to promote the event, or helping with logistics. Our own Dibya Prakash wil be there. See the BarCampPune Wiki for more details.

Technorati Tags: BarCampPune
Blogs linking to this article

Ruby Class Hierarchy

2006-03-10T07:37:00.000+05:30

A good way to learn Ruby is to learn the Class Hierarchy, right at the start. That way you know where everything fits. Thanks to Pierre Garigue for this tip.

Technorati Tags: Ruby Class Hierarchy
Blogs linking to this article

Ruby Quickstart

2006-03-09T13:33:00.000+05:30

For those who are too lazy to install Ruby, but would like to play with it, check out
try ruby! (in your browser)

Second meet: Free Ruby/Rails Workshop

2006-03-08T14:42:00.000+05:30

PuneRuby in association with Reevik Technologies Pvt. Ltd is pleased to announce the following 'free' workshop for its members.

Venue: Symbiosis Institute of Computer Studies and Research, 7th Floor, Atur Centre, Gokhale Cross Road, Model Colony, Pune-411016

Date: Sunday, 26th March 2006

Time: 1400 to 1800 hrs

Schedule:
(a) QuickRuby by Satish Talim
(b) Advanced Ruby and Welcome to Rails playground by Dibya Prakash

This workshop is restricted to PuneRuby members:

(a) Developers - 20
(b) Corporate - 5
(c) Students - 5
(d) Reserved seats - 5

Registration is on a first-come-first-serve basis. Kindly send the following information to satish.talim@gmail.com

(a) Name and Postal address
(b) Email id
(c) Contact number
(d) Whether a Student / Developer / Corporate
(e) Company name and designation
(f) Years of software experience
(g) What's your interest in Ruby and Rails?

Selected members will have to pay a nominal fee of Rs 50-00 towards snacks etc.

Decision of the organizers is final and binding.

Technorati Tags: Second meet: Free Ruby/Rails Workshop
Blogs linking to this article

Interactive Ruby

2006-03-06T11:21:00.000+05:30

Interactive Ruby means using a Command window. irb is a Ruby Shell, useful for trying out Ruby code. When you installed your Ruby software, the System Environment variable path is already set to point to the bin folder of Ruby.
To use irb, open a new Command window and type:

irb --simple-prompt

A prompt appears as >>

You can place a Ruby program directly on the command line. For example, you can start using this as a simple calculator. If you type 3+4 and then press the enter key, you get 7. Typing exit or quit, closes the Command window.

Technorati Tags: Interactive Ruby
Blogs linking to this article

Installing Ruby

2006-03-05T08:18:00.000+05:30

First, check whether Ruby is already installed. Open a Command window and type:
ruby -v
(-v tells the interpreter to print the version of ruby), then press the Enter key. If ruby is installed, you will see a message something like the following:
ruby 1.8.4 (2005-12-24) [i386-mswin32]
If Ruby is not installed, download this one-click installer. Do a full install. The current version of Ruby is 1.8.4. Ruby releases with even subversion numbers - 1.6, 1.8, and so on - are stable, public releases.

Technorati Tags: Installing Ruby
Blogs linking to this article

What is Ruby?

2006-03-02T11:34:00.000+05:30

An article What is Ruby best descibes it - Ruby is a pure object-oriented programming language with a super clean syntax that makes programming elegant and fun. Ruby successfully combines Smalltalk's conceptual elegance, Python's ease of use and learning, and Perl's pragmatism. Ruby was created in 1993 by a Japanese, Yukihiro Matsumoto, a.k.a "Matz", and has started to become popular worldwide in the past few years as more English language books and documentation have become available.

Technorati Tags: What is Ruby?
Blogs linking to this article

PuneRuby First Meet Held

2006-03-02T11:15:00.000+05:30

The group held it's first ever meet in Pune on 25th Feb. 2006 at Symbiosis Institute of Computer Studies and Research, 7th Floor, Atur Centre, Gokhale Cross Road, Model Colony, Pune-411016.

The meet was attended by over 15 members (probably the largest ever Ruby meet in the world!). The theme of the meet was a discussion about Ruby and Ruby on Rails (ROR) and was presented by Dibya Prakash and Shubhangi Bhagwat. The next meet is scheduled for the last week of March 2006.

Technorati Tags: PuneRuby First Meet Held
Blogs linking to this article

PuneRuby First Meet

2006-02-07T13:34:00.000+05:30

PuneRuby is holding it's first-ever Ruby/Rails meet at Symbiosis (SICSR), Model Colony on Saturday, 25th Feb 2006 from 4 pm to 8 pm. The schedule is as follows:

4 to 5 pm - An Introduction to Ruby and Rails by Dibya Prakash of Reevik Technologies
5 to 6 pm - Code Generator by Shubhangi Bhagwat of Symantec
6.00 to 6.30 pm - Tea break
6.30 to 7.30 pm - Agile Development by Dibya Prakash

Join the PuneRuby group for free here - http://groups.yahoo.com/group/puneruby/

All are welcome.

Technorati Tags: PuneRuby First Meet
Blogs linking to this article

First Post

2005-12-30T18:06:00.000+05:30

The PuneRuby discussion group about the dynamic programming language Ruby and the coolest framework Ruby on Rails, was started on Nov. 18, 2005. Today, we have launched our own blog. As of today, we have 19 members and we are sure that the group will grow by leaps and bounds. You too can join our group by sending an email to: http://groups.yahoo.com/group/puneruby/

We plan to have our first ever meet sometime in Jan. 2006 and preparations are on for the same. We shall keep you posted, so keep reading this blog.

Technorati Tags: First Post
Blogs linking to this article