Nordic Ruby 2011

Saturday, June 18, 2011

bitcoin==

con-currency?

Me!José! ♥Saturday, June 18, 2011

WWFMD?Saturday, June 18, 2011

Public Service Announcements

SIGSEGV is bad

neversaydie

begin # something dangerousrescue NeverSayDie # fix memoryend

"Not working in production mode"

DO NOT USE THIS SOFTWARE

ruby -w

def hello x = Object.new # warning 10 + 10end

warning: assigned but unused variable - x

How deprecation notices SHOULD be

written

class Foo def deprecated if $VERBOSE warn "hey bro, don't call this" end 10 endend

RSpec Problem

warning: useless use of == in void context

it "passes" do 10.should == 10 11.should == 11end

def check(thing)end

def deprecated check 10.should == 10 check 11.should == 10end

@tenderlove

AT&T, AT&T logo and all AT&T related marks are trademarks of AT&T Intellectual Property and/or AT&T affiliated companies.

Ruby Core Team

Rails Core Team

White Guy

Story about Geethika and pinochle, java, etc

It's TYRA!

Story about Geethika and pinochle, java, etc

<3 <3 <3

"Congratulations, you just made us not consider Rails

for anything anymore despite our coders liking it."

SWEDEN!

IKEA!Saturday, June 18, 2011

MEATBALLS!Saturday, June 18, 2011

SWEDISH FISH!Saturday, June 18, 2011

Made in Canada!Saturday, June 18, 2011

How do you catch such tiny fish?

Will you share your Swedish FishFishing spot?

Mountain Dewand my

Trail of Tears

Talk about Rails,Talk about work projects

Legacy Code

What isLegacy Code?

Untested

Not Understood

Maintainers are gone

Importance of Legacy Code

Old code containsKnowledge

Solves Today's Problems

All Legacy Code isNot Equal

TenderloveTear Formula

Code BurdenTears

Tears cried at time T

Volume at time T

Last Week

I LOVE hackingold code

Techniques

Universal

Techniques

Extending

Testing

Universal

Liskov substitution principle

A subclass can be used in place of it's

superclass

Object

Animal

Person

class Animalend

class Person < Animalend

def leg_count(animal) animal.legsend

def account_number(person) person.account_numberend

Single Responsibility Principal

Each class has one and only one responsibility

Each class has one reason to change

Method Extraction

class WebClient def get(url) url = URI.parse url Net::HTTP.get(url.host, url.path) endend

class WebClient def get(url) url = URI.parse url http_get end

private def http_get Net::HTTP.get(url.host, url.path) endend

class WebClient def get(url) url = URI.parse url http_get(url.host, url.path) end

private def http_get(host, path) Net::HTTP.get(host, path) endend

I don't like it, but it helps us to reason

Object#extend

class Foo def metaclass class << self; self; end endend

x = Foo.newp x.metaclass.ancestors

x.extend(Module.new { })p x.metaclass.ancestors

[Foo, Object, Kernel, BasicObject]

[#<Module:0x81c98>, Foo, Object, Kernel, BasicObject]

Code Seams

Testing

Load Path Hacking

$LOAD_PATH

ruby -Ifoo script.rb

require 'net/http'

[aaron@higgins project (master)]$ find .../test./test/lib./test/lib/net./test/lib/net/http.rb./web.rb

module Net class HTTP def self.get(host, path) "hello world" end endend

test/lib/net/http.rb

ruby -I test/lib web.rb

require 'web'require 'minitest/autorun'

class WebTest < MiniTest::Unit::TestCase def test_get client = WebClient.new response = client.get 'http://www.reddit.com/r/ruby' assert_equal 'hello world', response endend

require File.expand_path( File.join('..', 'foo'))

People don't know about -IRSpec and test/unit will set your -I for you

Heavy Handed

Good for Small APIs

Constant Hacking

require 'net/http'

class MyHTTP def self.get(host, path) "hello world" endend

WebClient.const_set(:Net, Module.new)WebClient::Net.const_set(:HTTP, MyHTTP)

class WebTest < MiniTest::Unit::TestCase def setup WebClient.const_set(:Net, Module.new) WebClient::Net.const_set(:HTTP, MyHTTP) end

def teardown WebClient.send(:remove_const, :Net) end

def test_get client = WebClient.new response = client.get 'http://www.reddit.com/r/ruby' assert_equal 'hello world', response endend

class WebClient def get(url) url = URI.parse url ::Net::HTTP.get(url.host, url.path) endend

Heavy Handed

Localized changes to one class

Still must mock entire API

Subclass Testing

require 'net/http'

Class.new

class WebTest < MiniTest::Unit::TestCase def test_get client = Class.new(WebClient) { def http_get(host, path) 'hello world' end }.new

response = client.get 'http://www.reddit.com/r/ruby' assert_equal 'hello world', response endend

Annoying Constructors

class Column def initialize(name, default, sql_type = nil, null = true) @name = name @sql_type = sql_type @null = null @limit = extract_limit(sql_type) @precision = extract_precision(sql_type) @scale = extract_scale(sql_type) @type = simplified_type(sql_type) @default = extract_default(default) @primary = nil @coder = nil end ....end

Many parameters,

don't care about some of them

Just Pass nil

def test_type_cast_true c = Column.new(nil, 1, 'int')

assert_equal 't', @conn.type_cast(true, nil) assert_equal 1, @conn.type_cast(true, c)end

Not Constructible

Can't construct, but want to break dependencies

pool = ActiveRecord::Base.connection_pool

Too hard to construct

pool = ActiveRecord::Base.connection_pool.dup

pool.extend(Module.new { def checkin conn @checkins << conn conn.object_id end})

Detecting Changes

Measure http_getclass WebClient def get(url) url = URI.parse url http_get(url.host, url.path) end

via Class.new

def test_http_get_count call_count = 0 client = Class.new(WebClient) { define_method(:http_get) { |host, path| call_count += 1 "hello world" } }.new

assert_equal 0, call_count client.get 'http://www.reddit.com/r/ruby' assert_equal 1, call_countend

Decide to call super or not

via Module.new

def test_http_get_count client = WebClient.new

call_count = 0 client.extend(Module.new { define_method(:http_get) { |host, path| call_count += 1 "hello world" } })

Extending

Huge Methods!

def table_rows rows[table_name] = fixtures.map do |label, fixture| if model_class && model_class < ActiveRecord::Base reflection_class.reflect_on_all_associations.each do |association| case association.macro when :belongs_to # Do not replace association name with association foreign key if they are named the same fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s

if association.name.to_s != fk_name && value = row.delete(association.name.to_s) if association.options[:polymorphic] && value.sub!(/\s*$([^$]*)\)\s*$/, "") # support polymorphic belongs_to as "label (Type)" row[association.foreign_type] = $1 end

row[fk_name] = ActiveRecord::Fixtures.identify(value) end when :has_and_belongs_to_many if (targets = row.delete(association.name.to_s)) targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/) table_name = association.options[:join_table] rows[table_name].concat targets.map { |target| { association.foreign_key => row[primary_key_name], association.association_foreign_key => ActiveRecord::Fixtures.identify(target) } } end end end end row end rowsend

Extract Methods

def belongs_to_row(association, row) # Do not replace association name with association foreign key if they are named the same fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s

if association.name.to_s != fk_name && value = row.delete(association.name.to_s) if association.options[:polymorphic] && value.sub!(/\s*$([^$]*)\)\s*$/, "") # support polymorphic belongs_to as "label (Type)" row[association.foreign_type] = $1 end

row[fk_name] = ActiveRecord::Fixtures.identify(value)end

def habtm_row(association, row) if (targets = row.delete(association.name.to_s)) targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/) table_name = association.options[:join_table] rows[table_name].concat targets.map { |target| { association.foreign_key => row[primary_key_name], association.association_foreign_key => ActiveRecord::Fixtures.identify(target) } } endend

def table_rows rows[table_name] = fixtures.map do |label, fixture| row = fixture.to_hash

if model_class && model_class < ActiveRecord::Base

# If STI is used, find the correct subclass for association reflection reflection_class = if row.include?(inheritance_column_name) row[inheritance_column_name].constantize rescue model_class else model_class end

reflection_class.reflect_on_all_associations.each do |association| case association.macro when :belongs_to belongs_to_row(association, row) when :has_and_belongs_to_many habtm_row(association, row) end end end

row end rowsend

Extract Object

class RowFilter def rows fixtures.map do |label, fixture| row = fixture.to_hash if model_class && model_class < ActiveRecord::Base # If STI is used, find the correct subclass for association reflection reflection_class = if row.include?(inheritance_column_name) row[inheritance_column_name].constantize rescue model_class else model_class end

reflection_class.reflect_on_all_associations.each do |association| case association.macro when :belongs_to belongs_to_row(association, row) when :has_and_belongs_to_many habtm_row(association, row) end end end row end endend

class RowFilter attr_reader :fixtures, :model_class

def initialize(fixtures, model_class) @fixtures = fixtures @model_class = model_class endend

def table_rows filter = RowFilter.new(fixtures, model_class) rows[table_name] = filter.rows rowsend

Huge Classes!

Look at Method Names

Look at shared instance variables

Group Similar Methods

Use SRP to create a new class

Then Delegate.

All API calls

Once we had extracted the HTTP methods to their own functions, could reason about HTTP api.

class WebClient def initialize(client = Net::HTTP) @client = client end

def get(url) url = URI.parse url http_get(url.host, url.path) end

private def http_get(host, path) @client.get(host, path) endend

class TestHTTP < Struct.new(:data) def get(host, path) data[[host, path]] endend

class WebTest < Test::Unit::TestCase def test_get_home mockhttp = TestHTTP.new({ ['localhost', '/~aaron/'] => 'hello' }) wc = WebClient.new mockhttp assert_equal 'hello', wc.get('http://localhost/~aaron/') endend

We define expectations

Not Bound to HTTP

Legacy code can make you cry

But it doesn't have to

Don't be afraid!

Ruby is your mocking framework

Credits & More Info

Open Questions?

Do you like mocking / stubbing?

How do these testing tools impact your API?

Do you like hearts?

How about kittens?

<3 <3 <3

Nordic Ruby 2011

Technology

Transcript of Nordic Ruby 2011

[RuPy 2011] Automatic Acceptance Tests in Ruby

SEB’s Nordic Hedge Fund Investor Survey 2011

Ruby on Rails - ETyC 2011

Deborah Wiles – Love, Ruby Lavender Little Read 2011.

Ruby for Women, December, 2011

Deferred Processing in Ruby - Philly rb - August 2011

Ruby on rails gds 2011

Bentleyuser.dk Årsmøde 2011 Nordic Civil 2011 · Bentleyuser.dk Årsmøde 2011 Nordic Civil 2011 14.-16. November 2011, Munkebjerg Hotel, Vejle . X11 . New Tools: Creating Roundabout

"Maskiner som leser" (Nordic Research 2011)

Ruby for Women, January, 2011

Cybex Ruby Owner's Manual 2011

Gamification for Game Developers - Nordic Game 2011

Maj SH of Ruby International v. Lim (2011)

RVM and Ruby Interpreters @ RSC Roma 03/2011

HFL Nordic Memory Book 2011

Workshop de Ruby - UFSCar 2011

Georg Mohr-Konkurrencen - NORDIC MATHEMATICAL CONTEST PROBLEMS AND SOLUTIONS…sol.pdf · 2011. 10. 20. · NORDIC MATHEMATICAL CONTEST PROBLEMS AND SOLUTIONS, 1987–2011 PROBLEMS

Pink Ruby Winter 2011

NORDIC INNOVATION PUBLICATION 2011:01 // OCTOBER … · NORDIC INNOVATION PUBLICATION 2011:01 // OCTOBER 2011 Key innovation indicators Learning from principles and practices applied

RubyMasters 2011 - Beyond Ruby with NodeJS