IronShay

Ironing code, geek t-shirts and even presentations!

NAVIGATION - SEARCH

IronRuby is going to Japan!

If you don’t already know, Japan is where the Ruby language was created, back in 1995. This is the origin of this great language, this is where it all started!

So I’m very excited to announce that on this August, IronRuby is coming to Japan!

IronRuby in Japan

I’m going to visit Japan in August and talk about IronRuby! I will participate in two very different conferences – TechEd Japan and RubyKaigi.

TechEd Japan, the main Japanese .NET conference, will take place between August 25th to August 27th. I’m going to speak on day 2 of the conference (the 26th) about IronRuby for .NET developers.

TechEd Japan 2010 

RubyKaigi 2010 will take place between August 27th to August 29th. It is a world-class Ruby conference that hosts Ruby great minds from all over the world like Yukihiro Matsumoto (the creator of Ruby), Yehuda Katz, Jeremy Kemper and others. I’m going to give there a talk on the 29th, named “IronRuby – What’s in it for Rubyists?”.

RubyKaigi 2010

I’m so excited to visit Japan and present in front of both .NET and Ruby developers. Maybe this will be the bridge between the large Japanese Ruby community and the large Japanese .NET community!

Shay Friedman – bridging between developers since 1983!

See you there!
Shay.



Working with .NET Lowercase Namespaces and Classes in IronRuby

[if you have no idea what IronRuby is, read this first]

.NET has some common naming conventions that everybody uses. One of them is that namespace and class names are PascalCased. However, like in real life – rules are meant to be broken. In C#/VB.NET there is no real constraint on this convention – you can name your namespaces/classes using all lowercase or in any other way you want (and I ask, why?). Therefore, the next C# code is totally acceptable:

namespace demo
{
  class library
  {
    public void Print()
    {
      Console.WriteLine("Yay! I've broken the rulez! I'm a smartass!");
    }
  }
}

The Problem

Unlike C#/VB.NET, in Ruby you must start namespace (which is called a module) and class names with a capital letter. And there you have it – clash of the titans.

Clash of the Titans  
Now, normally you wouldn’t care about that but if you’re using IronRuby, you’re right in the middle here. On the one hand, you’d expect IronRuby to allow you to use .NET classes with their original names but on the other hand, the Ruby language just doesn’t allow that.

The Solution

To solve this issue we must use some kind of a workaround. Luckily, IronRuby provide a pretty simple workaround. For example, consider the next C# classes (let’s assume this code is built into an assembly named demo.dll):

namespace demo
{
  public class library
  {
    public void Print()
    {
      Console.WriteLine("Hello");
    }
  }

  public class LibraryWithGoodName
  {
    public void Print()
    {
      Console.WriteLine("Hello");
    }
  }
}

This is how you use it from IronRuby:

require "demo.dll"

# Get the namespace object
Demo = Object.const_get("demo")

# Get the lowercase library class object
Library = Demo.const_get("library")

# Use the library class:
lib = Library.new
lib.Print

# Another alternative to create a library class instance in one line:
lib = Object.const_get("demo").const_get("library").new
lib.Print

# Use the LibraryWithGoodName class:
lib1 = Demo::LibraryWithGoodName.new
lib1.Print

All the best,
Shay.



Starting Using IronRuby in 25 Minutes

On the journey to cross the language barrier that stands between IronRuby and .NET developers, this post will teach you everything you need to know to start using IronRuby. And the intention is that it will not take you more than 25 minutes. So go grab a coffee and start reading.

….

I’m waiting… go get that coffee already!

….
………
…………

Good! Now that we’re ready to go, let’s start!

So, first task for you, which will take the first 15 minutes of our time is to learn Ruby. This is exactly the reason for my latest post – Learning Ruby in 15 Minutes. Go ahead and read it and then come back here.

……………

OK. Now that you know Ruby and we still have 10 minutes left to learn IronRuby. Not a lot of time but hey, that’s all we need.

First of all – Download and Install IronRuby

Well, to use IronRuby you must first download and install it. So if you have .NET 4 installed, download the IronRuby installer from here. Otherwise, download this version which supports .NET 2.0 SP1 and above. This will download an MSI file, so to install IronRuby just run the installer, then click Next, Next, Next and Finish. That’s it, you’re done.

Pay attention that IronRuby supports all the Ruby language features. Therefore, everything you’ve learned on the 15 minute Ruby course apply to IronRuby as well.

Running IronRuby Files

When running IronRuby files, the important thing to have is an IronRuby file… Ruby code files are usually saved with the .rb extension. Hence, after you have written your precious Ruby code, save it to a file with the .rb extension. For example, let’s say we save the next code in a file named hello.rb:

# Class definition
class Hello
  def say_hello
    puts "Hello!"
  end
end

# The code that will get executed
hello = Hello.new
hello.say_hello

To run this file you will need to open the command prompt. This is done in Windows via the Start->Run dialog (shortcut: WinKey+R) – input cmd in this dialog and the command prompt will open. As soon as you have the cmd window opened, you can run IronRuby files.

Running IronRuby files is done using the IronRuby interpreter which exists within the ir.exe file. Therefore, the command to run IronRuby files starts with ir.exe followed by the file name. If the run file is placed within the current directory you only need to specify the name of the file. If it is located in a different folder, you need to specify the entire path. For example, the next cmd window screenshot shows running the hello.rb file from the previous sample:

Running IronRuby Files

Referencing .NET Assemblies

The expertise of IronRuby is its integration with .NET assemblies - you can load any .NET assembly and use it from Ruby code.

Doing so is just like loading other Ruby files – via the require method (which was mentioned on the Learning Ruby in 15 minutes post). All you need to do is to pass the name of the assembly (with or without the full path) to the require method:

require 'MyCustomAssembly.dll'
require 'C:\Demo\SomeAssembly.dll'

In case the assembly is located in the GAC or is signed, pass its strong name:

require "System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 

If you want to learn more about referencing .NET assemblies, look here.

Using .NET Assemblies

After you load .NET assemblies using the require method (or the other alternatives), you can use everything inside these assemblies. For this you need to be aware of a few things:

  • The namespace delimiter in Ruby is ::. Therefore, System.Windows.Forms will be System::Windows::Forms in IronRuby.
  • The method include is similar to C#’s using keyword so you can take advantage of it. For example: include System::Windows::Forms.
  • When a .NET assembly is loaded into IronRuby context it goes through a name mangling process. This process converts the names of the .NET properties and methods to their equivalent Ruby name (because Ruby has different naming conventions). You will still be able to use the C# name, but it is important to be familiar with that.
    The name mangling process converts the .NET’s CamelCase convention to Ruby’s lowercase_and_delimited convention. Read more about this process here.

The next sample demonstrates using the System.Windows.Forms assembly to create a simple form with a label via IronRuby. Pay attention to the names of the methods and properties which are the results of the name mangling process:

require "System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 

include System::Windows::Forms

# Create a form object
form = Form.new

# Create a label
label = Label.new
label.auto_size = true

# Set the text of the label
label.text = "IronRuby Rulezzzzz!!!"

# Add the label to the form
form.controls.add label

# Show the form
form.show_dialog

Conclusion

You have successfully crossed the language barrier! Congratulations!

This post and the one before it taught you all the basic stuff. Even though it is enough to get started, I think your experience with Ruby and IronRuby will be much more fulfilling after you learn more advanced subjects. There are numerous sites, tutorials and books ( *caugh* IronRuby Unleashed *caugh*) you can read and a great deal of forums and mailing lists where you can ask questions. So don’t be afraid to start, we’re all here to help!

Enjoy!
Shay.

kick it on DotNetKicks.com Shout it



Learning Ruby in 15 Minutes

A problem I run into a lot when evangelizing IronRuby is the language barrier. Just like real life, people are scared when they visit a country where they do not know the local language. Same thing with C# developers who are afraid to learn other languages.

However, some languages are more easier to learn than others. For example, English would be much easier to learn than Hebrew. This is exactly the case with Ruby – it is a very easy-to-learn language and the title of this post is not a scam, I do mean to teach you all you need to know about Ruby in order to start working in the next 15 minutes. After you have these basics, my next post will be about IronRuby and the fundamentals you need to know when using it.

Sit tight, here we go.

Variables

Well, Ruby has a dynamic type system. This means that it really actually has a type system (unlike a lot of people think) but it is totally implicit. So to declare a variable you just write the name, followed by an equal sign and then the value:

# Creating variables
num = 1 # setting a variable named "num" with a numeric value of 1
str = "Hello" # setting a variable named "str" with a textual value of "Hello"
arr = [1, 2, 3] # setting a variable named "arr" with an array of 3 numbers - 1, 2 and 3
hash = { "key1" => "my value", "key2" => "another value" }  # creating a hash with key value pairs

# Reading variables
num + 1 # adding 1 to num
puts str # prints the value of str to the console
arr[0] # retrieve the first value of the array
hash["key1"] # retrieve the value from the hash with the key of "key1"

Symbols

Symbols are a cool thing in Ruby. They are used in various cases and you will identify them by the colon in front of their name. You can think of them as enum values – they are not strings but they are not variables either – they are there to be used as keys to other values. You will run into them a lot with hashes. For example, instead of the hash I created on the previous sample, the next one would be more “correct”:

hash = { :key1 => "my value", :key2 => "another value" }
hash[:key1]

Conditions

Conditions in Ruby are pretty straight forward:

if condition then
  # something
elsif other_condition then
  # somethng else
else
  # other something
end

The condition itself is very similar to C# – you use the == sign to compare between two values (or > and <). To concatenate multiple conditions, use the and and or keywords like if a > 1 and a < 5 then.

Additionally, Ruby conditions have a cool little twist – the unless condition. The unless condition is very similar to if. The difference between them is that unless is like if not. This means that you never need to write negative conditions like a != 1. Instead, you use the unless condition:

unless a == 1 then
  # something
end

Reverse Conditions

To enhance the readability of the code, Ruby offers something that is called “reverse conditions”. This language feature enables writing one-line conditions with the action to do before the condition. For example, the next statement adds 1 to variable a if a is greater than 5:

a = a + 1 if a > 5

Reverse conditions can be used with if as well as with unless.

Loops

Ruby features three loops out-of-the-box – while, until and for. while is the same as C#’s while:

while condition do
  #something
end

The until condition is similar to the concept of the unless condition – it is the same as while not:

a = 0
until a == 5 do
  puts a
  a = a + 1
end

The for loop is similar to the foreach loop in C# – it iterates through a collection:

a = [1,2,3]
for item in a do
  puts item
end
# prints
# 1
# 2
# 3

Apart for these loops, when coding Ruby you will find yourself using the enumeration capabilities of the different objects. For example, to run a loop 10 times, just use the times method of integer numbers:

10.times do |i|
  print i
end
# prints: "0123456789"

Another way, if you want to loop over all the number from 5 to 9, you can use the upto or downto methods of integer numbers:

5.upto(9) do |i|
  print i
end
# prints: "56789"

9.downto(5) do |i|
  print i
end
# prints: "98765"

In addition, to loop over collections, you can call their each method (instead of using the for loop):

a = [1,2,3]
a.each do |item|
  puts item
end
# prints:
# 1
# 2
# 3

Error Handling

Handling errors in Ruby is done very similar to C# or other languages. The flow is as such:

begin
  # something risky
rescue SomeException => s # catch specific exception type (SomeException) 
                                                        # and put in variable named s
  puts "Oh no!"
rescue Exception => x # catch all exceptions and put in x
  puts "Why??? Why???"
rescue # catch all exceptions without setting the exception to a variable
  puts "The horror!!!!"
end

Notice that only one rescue block will be executed. If multiple rescue blocks match the raised exception, the first match will be executed and the rest will be ignored.

Blocks

Blocks are very common in Ruby. Actually, every time you see code that is enclosed inside do and end keywords or curly brackets {}, you see a block. You can think of blocks as anonymous methods in C#.

So as mentioned, there are two ways to define a block – inside do and end keywords or inside curly brackets. There is no major difference between these two syntaxes but the common practice is to use curly brackets when you have only one line of code in your block and do-end on other cases.

When using Ruby methods and the different libraries, you will notice that a lot of methods retrieve blocks and execute them. In such a case, the block will be added to the method call at the end, after you pass all the other parameters. For example, the next code is totally legit:

my_method("some string param") do
  puts "Inside a block!"
end

Blocks can receive parameters as well. To specify the parameters, just write their names between vertical bars after the do keyword or after the opening curly brackets:

my_method("value...") do |param1, param2, param3|
  puts param1 + param2 + param3
end

my_method("value...") { |param1, param2, param3| puts param1 + param2 + param3 }

There are more types of code containers in Ruby like lambdas and procs and you will want to use them in slightly different scenarios. Anyway, I’m not going to discuss them here because they are not as common as blocks (but it is recommended you read a bit about them and know what they mean).

Methods

Methods are basically blocks with names… I guess this is a bit of a very generic definition but it’s generally what it is. The way to define a method is by using the def keyword, then the name of the method (method names in Ruby should start with a lowercase letter), then its parameters (if any), then the code and end at the end:

def method_name(param1, param2)
  # something
end

A method can be declared inside a class or outside it. In case you define it outside of a class, it will be available from anywhere within your code. When a method is declared inside a class, it is available only via a class instance (for instance methods) or the class object (for class methods).

Method Return Value

Any method returns a value in Ruby. You do not need to use any keyword (like return in C#) to return a value – the last statement return value will be returned to the caller.
For example, the next method will return 1:

def always_returns_1
  1
end

Additionally, you can use the return keyword to explicitly return a value. When the return keyword is used, it acts like in C# and also exits the method. For example, the next sample method always returns 1:

def always_returns_1
  return 1
  return 2
end

Calling Methods

Executing a method is very straight forward – just write its name and it will run. You should also specify parameters (if any) and pay attention here – parenthesis is optional.
For example, the next sample demonstrates the different method calls available:

def add(a, b)
  a + b
end
 
result1 = add(1, 2)
result2 = add 1, 2

Be careful when using parenthesis – the opening bracket must come exactly after the method name without any space. This means that add(1, 2) and add (1, 2) are not the same!

Classes

A class is an object that gathers methods, properties and variables that together generate a single logical unit, just like C# classes. The difference between C# classes and Ruby classes is that in Ruby, a class inherits from the Class object (which eventually is an Object object) and in C#, a class inherits directly from Object.

To define a class you start with the class keyword followed by the name of the class, which must start with an uppercase letter. For example, the next sample defines an empty class named EmptyClass:

class EmptyClass
  # Everything goes here
end

Instance Methods

To create instance methods, you just add method definitions inside the class definition (between the class name and the end keyword):

class MyClass
  def my_method
     # something
  end
  # more methods...
end

Constructor

Sometimes you need to run some initialization code when the class is created. This is done via a constructor method and in Ruby, the constructor is defined in a method named initialize.
For example, the next class will print “Hello there” when it is created:

class HelloClass
  def initialize
    puts "Hello there"
  end
end

Notice that a constructor method can retrieve parameters just like any other method. To do that, just specify parameters for the initialize method.

Class Methods

Class methods are like static methods in C# – they are methods which can be invoked without creating an instance of the class. To create a class method, use the self keyword before the name of the method. For example, instead of say_hello, name the method self.say_hello:

class MyClass
  def self.say_hello
    puts "Hello"
  end
end

Instance/Class Variables

Apart from methods, classes can contain variables. There are two kinds of variables:

  • Instance variables – they are instance-specific and are available to instance methods.
  • Class variables – they are shared between all instances of the class and are available to all methods of the class (both instance and class methods). Similar to static variables in C#.

Instance variables are declared with an at sign (@) in front of them. For example - @first_name. Class variables are declared with two at signs (@@) in front of them. For example – @@instance_counter.

This is very simple and I think the next list will make it even clearer:

  • first_name – local variable (available in the current scope only).
  • @first_name – instance variable (available in the current instance only).
  • @@first_name – class variable (available in all class instances).

Creating Class Instances

To create a class instance we use the new method on the class. This is a built-in behavior, just like the new keyword in C#. Calling the new method will eventually execute the class’ constructor (the initialize method).
For example, the next code contains a simple class definition with a constructor and afterwards I create an instance of the class:

class Hello
  def initialize
    puts "Hello"
  end
end

# Init the class
hello = Hello.new # prints "Hello"

If the initialize method contains parameters, you will need to pass them on the new call.

After the class instance exists, you can execute its instance methods using a dot. For example, the next sample contains a class definition and a method call afterwards:

class Hello
  def say_hello
    puts "Hello"
  end
end

hello = Hello.new
hello.say_hello # prints "Hello"

To execute class methods you don’t need to initialize a class instance and you just use the class name instead of the class instance:

class Hello
  def self.say_hello
    puts "Hello"
  end
end

Hello.say_hello

Using Code from Other Files

As your application grows, you will probably want to separate your code into several files to ease maintenance. Moreover, you will probably want to use Ruby libraries or even load .NET assemblies (with IronRuby). To do so, Ruby provides a method named require which retrieves the name of the file you want to load.

For example, the next sample will load a Ruby file named mylibrary.rb:

require 'mylibrary.rb'

You can also specify the full path to the file.

After you load a file with the require method, all the classes, methods, variables, whatever that exist in this file will be available in the current file (similar to the Add Reference concept in .NET).

[Loading .NET assemblies with IronRuby are done the same way but I will talk about it on the next post.]

Conclusion

Well, 15 minutes have passed and now you know all the basics of the Ruby language. You can now go to a Ruby restaurant and ask the waitress for a delicious meal with no worries. 
That is all you need to get started. That’s all. But if you like it, I do recommend you to learn more because Ruby have so much more to offer.

Stay tuned… the next post in this series will teach you all you need to know about IronRuby.

All the best,
Shay.

P.S. If you think something is missing from here, I need to clarify subjects, I need to delete it all or anything else, please let me know.



Slides and Videos of my Talks at Epicenter and NDC

I’ve just uploaded the slides from my recent sessions at the Epicenter and NDC conferences. They appear on the presentation page as well.

NDC 2010 – Riding IronRuby on Rails (Norway, June 2010)

Abstract: The most famous Ruby–driven framework is, by far, Ruby on Rails. With IronRuby, .NET developers can now take advantage of this incredible web framework without leaving their comfort zone. In this session, Shay Friedman will build an entire Web 2.0 site from scratch while using and explaining the key features of Ruby on Rails.
Come and see what Ruby on Rails is all about and what's made it the success it is today.

You can also watch the session video – streaming, iPod video (320x240), MPEG-4 for QuickTime (1280x480)

NDC 2010 – Practical IronRuby (Norway, June 2010)

Abstract: Ruby has been a home for some great innovative frameworks like Ruby on Rails, Cucumber and Rake. IronRuby version 1.0 has recently been released, unleashing the power of Ruby to the .NET world.
In this session you will get familiar with the Ruby language and its amazing ecosystem and you will learn to take advantage of it in your everyday development tasks.
Come and see how this great new addition to the .NET family makes your development process faster, clearer and happier!

You can also watch the session video – streaming, iPod video (320x240), MPEG-4 for QuickTime (1280x480)

Epicenter 2010 – Ruby on Rails Vs. ASP.NET MVC (Ireland, June 2010)

Abstract: 2010 is the year when two great web development frameworks arrive at the .NET world – ASP.NET MVC 2.0 and Ruby on Rails (via IronRuby). It is the time to get to know these frameworks and learn their advantages and disadvantages. In this session I will walk you through the good, the bad and the ugly of both frameworks providing you points to consider when coming to choose one of them.
Come and see how these two wonderful web development frameworks collide!

Epicenter 2010 – ASP.NET MVC (Ireland, June 2010)

Abstract: Since the early days of ASP and later on ASP.NET, web development has always been a confusing experience. Several different architectures were suggested over the years, all of them struggled with the same goal – to make the code clear, clean and easily maintainable. Eventually, Microsoft took up the glove and created the framework that would change web development in Microsoft environment forever – ASP.NET MVC.
In this session Shay Friedman will take you on a journey to explore the different capabilities of ASP.NET MVC 2.0 by building an entire web application from scratch. Come and see the future of web development in the .NET world!

Epicenter 2010 – Practical IronRuby (Ireland, June 2010)

Abstract: Ruby has been a home for some great innovative frameworks like Ruby on Rails, Cucumber and Rake. IronRuby version 1.0 has recently been released, unleashing the power of Ruby to the .NET world.
In this session you will get familiar with the Ruby language and its amazing ecosystem and you will learn to take advantage of it in your everyday development tasks.
Come and see how this great new addition to the .NET family makes your development process faster, clearer and happier!

Enjoy!
Shay.



IronRuby Posts Recap

During the last couple of years I’ve written numerous posts about various aspects of IronRuby. Now that IronRuby 1.0 is around and people start using it, it is a wonderful chance to gather all these posts together to help you get the information you need in a fast and easy way.

Feel free to share your thoughts with me via comments/contact form/twitter/…. Enjoy!

General

Testing .NET Code

IDEs

Exploiting .NET Libraries

Coolness

IronRuby Unleashed

If you want even more, I recommend you visit the presentations page for slides and demo code from my past presentations.

All the best,
Shay.



New IronRuby Articles

I’ve recently told you about my IronRuby articles and promised you more… so here is me keeping my promise!

Two new articles of mine were published in the last two days:

I hope you enjoy these! and stay tuned because there are more to come!

All the best,
Shay.



Announcing Ruby Meetup at NDC2010

As I’ve told you before, I’m going to talk about IronRuby and IronRuby on Rails in the upcoming Norwegian Developer Conference.
However, it’s not only me that’s talking about IronRuby in NDC2010! Scott Bellware and Ben Hall both have one or more talks involving the Ruby language and how you can exploit it in your .NET development process.

In total, NDC is hosting 5 (!) different IronRuby-related sessions and by that, it is the first one to acknowledge the importance of IronRuby to the .NET community. Kudos for that!

NDC2010 + Ruby = Love!

With that in mind, I’m happy to announce that there’s more!

Scott came up with the idea, Anders helped with the organization and it came alive: the Ruby Meetup in NDC 2010!

The Ruby Meetup is going to take place during launch time of the last day of the conference – June 18th, 12:50-13:40 featuring Scott Bellware, Rob Conery, Ben Hall and myself!
The idea is simple – the panel is about Ruby and IronRuby but we don’t have anything prepared except our knowledge. This means that it’s up to you to come with the questions/comments/problems/whatever and throw them at us!

Hoping to see you all there!
Shay.

P.S. If one of you can bring a CD with IronRuby to the meetup, then we can drop it and finally find out if it makes a sound!



Upcoming Gig: NDC 2010

This June is going to be SENSATIONAL!

On mid June I’ll be doing my way towards Norway to participate in the Norwegian Developer Conference, AKA NDC2010. This conference has a really awesome lineup and I’m really honored to take part in it.

ndc2010

The conference will take place on June 16-18 in Oslo Spectrum in Oslo.

I’ll be doing two sessions, both on the last day of the conference:

When: June 18th, 09:00
Title: Practical IronRuby
Abstract:
Ruby has been a home for some great innovative frameworks like Ruby on Rails, Cucumber and Rake. IronRuby version 1.0 has recently been released, unleashing the power of Ruby to the .NET world.
In this session you will get familiar with the Ruby language and its amazing ecosystem and you will learn to take advantage of it in your everyday development tasks. Come and see how this great new addition to the .NET family makes your development process faster, clearer and happier
(Be prepared for mind-blowing demos!)

When: June 18th, 13:40
Title: Riding IronRuby on Rails
Abstract:
The most famous Ruby–driven framework is, by far, Ruby on Rails. With IronRuby, .NET developers can now take advantage of this incredible web framework without leaving their comfort zone. In this session, Shay Friedman will build an entire Web 2.0 site from scratch while using and explaining the key features of Ruby on Rails.
Come and see what Ruby on Rails is all about and what's made it the success it is today.

See you there!
Shay.



Upcoming Gig: Epicenter 2010

The conference season is coming and it’s time to let you know where and when you can see and meet me!

So…

This June I’ll be speaking at the Epicenter 2010 conference, taking place on June 8th-11th in Dublin, Ireland.

epicenter 2010

The conference will be hosted in the Arts building of Trinity College, which just looks awesome:

Anyways, it’s technology we’re interested in! So I’m going to have two talks in the conference:

When: June 9th, 11:00
Title: Practical IronRuby
Abstract:
Ruby has been a home for some great innovative frameworks like Ruby on Rails, Cucumber and Rake. IronRuby version 1.0 has recently been released, unleashing the power of Ruby to the .NET world.
In this session you will get familiar with the Ruby language and its amazing ecosystem and you will learn to take advantage of it in your everyday development tasks.
Come and see how this great new addition to the .NET family makes your development process faster, clearer and happier!
(Get ready for some crazy demos here!)

When: June 10th, 15:15
Title: Ruby on Rails Vs. ASP.NET MVC
Abstract:
2010 is the year when two great web development frameworks arrive at the .NET world – ASP.NET MVC 2.0 and Ruby on Rails (via IronRuby). It is the time to get to know these frameworks and learn their advantages and disadvantages. In this session I will walk you through the good, the bad and the ugly of both frameworks providing you points to consider when coming to choose one of them.
Come and see how these two wonderful web development frameworks collide!

In addition to these talks I’ll also participate on Wednesday’s evangelist night along with Jamie Van Dyke and Julian Fitzel.

By the way, I’m staying in Dublin for a few days after the conference as well so if you’re in Dublin, let me know and we’ll go grab a pint!

See you there!
Shay.