This document summarizes a presentation given by Colin Gemmell, a developer who transitioned from .NET to Ruby on Rails. It discusses his motivations for the switch, compares the development environments and practices between the two platforms, and touches on some of the benefits and challenges of Rails development.

1. From .NET to Rails,
A Developers Story

2. Who the f**k is
Colin Gemmell
.NET Dev for 3.5 years
Webforms, MVC, Umbraco
Big on ALT.NET ideals
Moved to Ruby on Rails in May 2010
Started the Glasgow Ruby User Group
in March 2011

3. Why Ruby and Rails
Cheaper than developing with .NET
Arguably faster and more productive
Easier to test your code
Open and free development

4. Why Ruby and Rails
This man pays me to.
@chrisvmcd

5. .NET Development Environment
Window XP/Vista/7
Visual Studio 20XX
Resharper or Code Rush

6. My First Ruby
Development Environment
Window XP/Vista/7
Rubymine
Cygwin
Ruby Gems
Interactive Ruby Console (irb)

7. Windows Problems
Rails traditionally deployed on Linux OS
Gem’s often use Linux kernal methods
or Linux Libraries
Engineyard investing on Rails development with
windows

8. Development Environment
VMware workstation
Ubuntu
Rubymine
VIM + a lot of plugins
Ruby Gems
Interactive Ruby Console (irb)

9. Development Environment
Find what is right for you.

10. Ruby
Ruby Koans (http://rubykoans.com/)

11. Ruby and SOLID
Single responsibility
Open/Closed
Liskov Substitution
Interface Segregation
Dependency Injection

12. Ruby and loose coupling
In .NET we use Interface and Dependency
Injection to achieve loose coupling
Ruby is loosely coupled by design.
Everything and anything can be changed.
Thanks to being a dynamic language and……

13. Ruby and Monkey Patching

14. Add New Functionality to Ruby
"Developer Developer Developer is awesome".second_word
NoMethodError: undefined method `second_word' for "developer developer
developer":String
class String
def second_work
return self.split(' ')[1]
end
end
"Developer Developer Developer is awesome".second_word
=== “Developer”
Extension methods anyone?

15. Changing implementation
class ZombieKiller
def kill
self.shotgun.fire
end
end
zombie_killer = ZombieKiller.new
puts(zombie_killer.kill)
=== Zombie head explodes
class ZombieKiller
def kill
self.axe.throw
end
end
zombie_killer = ZombieKiller.new
puts(zombie_killer.kill)
=== Zombie Falls off

16. Are you scared yet?
If the idea of monkey patching scares you a
little, it probably should. Can you imagine
debugging code where the String class had
subtly different behaviours from the String
you've learned to use? Monkey patching can
be incredibly dangerous in the wrong hands.
Jeff Atwood
http://www.codinghorror.com/blog/2008/07/monkeypatching-for-humans.html

17. Testing Ruby and Rails

18. Testing Ruby and Rails
Testing ensures code behaves correctly
Tests ensure code compiles
Debugging support patchy at best
Its all right, testing is a lot simpler

19. How I Tested .NET
[TestFixture] public class ZombieKiller : IZombieKiller {
public class ZombieKillerTest : SpecificationBase{ private IZombieKillerRepository _repo;
private ZombieKiller zombieKiller; public ZombieKiller(
private Zombie zombie; IZombieKillerRepository repo){
_repo = repo;
}
public override void Given(){
var repo = Mock<IZombieKillerRepository>();
public void Kill(Zombie zombie){
zombie = new Zombie(Strength.Week, zombie.status = "decapitated“;
Speed.Fast); repo.UpdateZombie(zombie);
zombieKiller = new ZombieKiller(repo); }
repo.stub(x => x.UpdateZombie).returns(true); }
zombieKiller.weapon = Weapon.Axe;
}
public override void When(){
zombieKiller.kill(zombie);
}
[Test]
public void should_depacite_zombie(){
zombie.status.should_eqaul("decapitated");
}
}

20. Example RSpec test
describe "when killing a zombie" do class ZombieKiller
class Zombie def kill zombie
def save zombie.attack_with self.weapon
true end
end End
end
class Zombie < ActiveRecord::Base
before do def attack_with weapon
@zombie = Zombie.new( #do some logic to see
#what happened to zombie
:strength => :week, :speed => :fast)
self.save
@zombie_killer = ZombieKiller.new(
end
:weapon => :axe)
end
@zombie_killer.kill(@zombie)
end
it "should be decapitated if hit with axe"
do
@zombie.status.should eql(:decapitated)
end
end

21. Range of Testing
In .NET there are a lot of test frameworks
Ruby test frameworks include TestUnit, RSpec,
Shoulda and Cucumber
Rails encourages testing at all levels.
All extremely well documented.

22. The Rails Way
One project layout and only one layout
Principle of least surprise
Change it at your own risk
Heavily based on conventions e.g.
ZombieController > ZombieControllerSpec
Zombie > ZombieSpec (or ZombieTest)
Zombie > ZombieController
This can be applied to .NET too

23. The Curse of Active Record
Makes really fast to get going with project
The number one reason for slow apps (IMHO)
Is to easy to write code that over uses the
database
Often don’t/forget to think about DB

24. The Curse of Active Record
1 class Session < ActiveRecord::Base 19 module SessionModel
2 # name > string 20 def self.included klass
3 # code > string 21 klass.extend ClassMethods
22 end
4 23
5 validates_uniqueness_of :name, :code 24 module ClassMethods
6 include SessionModel 25 def code_is_unique?(code)
7 26 return self.find_by_code(code).nil?
8 def generate_code 27 end
28 end
9 return if !(self.code.nil? || 29 end
self.code.empty?)
10 full_code = ""
11 while (true)
12 code = "%04d" % rand(9999)
13 full_code = “ABC#{code}"
14 break if
Session.code_is_unique?(full_code)
15 end
16 self.code = full_code
17 end
18 end
Spot the database calls...

25. The Curse of Active Record
class Session < ActiveRecord::Base module SessionModel
# name > string def self.included klass
# code > string klass.extend ClassMethods
end
validates_uniqueness_of :name, :code x 2 module ClassMethods
include SessionModel def code_is_unique?(code)
return self.find_by_code(code).nil?
def generate_code end
end
return if !(self.code.nil? || end
self.code.empty?)
full_code = ""
while (true)
code = "%04d" % rand(9999)
full_code = “ABC#{code}"
break if
Session.code_is_unique?(full_code)
end
self.code = full_code
end
end
This was production code. The names have
been changed to protect the innocent

26. .NET Deployment
.NET deployment predominantly through FTP or
copy to file share
But what about databases, migrations, queues,
externals dependencies etc.
Fear common place on deployment day

27. Ruby Deployment
Deployment is a solved problem in Rails
Built on several parts
Database migration come out of the box
Bundler gets dependency
Use of Chef or Capistrano for externals or
configuration changes
Platform as a service combine all of these e.g.
Heroku, Engineyard, Brightbox

28. Deployment
Shock horror its a demo

29. From .NET to Rails,
A Developers Story
Any Questions?
E-mail: pythonandchips@gmail.com
Blog: pythonandchips.net
Twitter: @colin_gemmell

30. Rails Scaling

31. Scaling Rails
John Adams, Twitter operations
http://tinyurl.com/6j4mqqb