Discussing language constructs with fellow developers in the context of solving a particular problem is something we do routinely. While most such conversations are productive and useful, a fair portion degenerate into angry brawls. A pattern we've observed in the latter situation is that a surprising number of times the argument is that "Why shouldn't I use language feature X to achieve objective Y- after all, the language supports X." In this talk Aakash and Niranjan walk through a few features of the Ruby language which when used wisely allows programmers to solve problems elegantly but if they are used without caution can lead to bad code.

1. But the Language
Supports it

2. aakash
dharmadhikari

3. aakash

4. @aakashd

5. niranjan paranjape

6. achamian

7. @niranjan_p

8. Engineering
http://github.com/c42

9. GOTO :context

10. design discussion

11. debate

12. rational arguments

13. defensive arguments

14. but the language
supports it

15. really?

17. OO/Ruby

18. library vs. domain

19. mechanic

20. maturity of the team

21. GOTO :begin
raise “it should have jumped to the next topic”

22. class Species
attr_accessor :type
HUMAN = "human"
# some code
def is_human?
self.type == Species::HUMAN
end
end

23. class GodClass
def environment_to_support(species)
case
when species.is_human?
{:feeds_on => ["Plants", "Meat"],
:required_elements_in_atmosphere => ["Oxygen", "Nitrogen"]}
when species.is_babel_fish?
{:feeds_on => "Brain wave",
:required_elements_in_atmosphere => []}
# so on
end
end
end

24. i love switch

25. tell don’t ask

26. class BabelFish < Species
def environmental_necessities
{:feeds_on => "Brain wave",
:required_elements_in_atmosphere => []}
end
end
class GodClass
def environment_to_support(species)
species.environmental_necessities
end
end

27. are “?” methods evil?

28. class User
def is_admin?
self.role == :admin
end
end
class ApplicationController < AbstractController::Base
def require_admin_privilege
unless current_user.is_admin?
head :unauthorized
end
end
end

29. Back to switch

30. should ‘switch’ be
banned?

31. so can I replace it with

32. if elsif elsif elsif ...

33. http://www.flickr.com/photos/santiagogprg/5023648200/

34. how about this?

35. class Species
@@environmental_necessities = {
"babel_fish" => {:feeds_on => "Brain wave"},
"human" => {} # so on
}
def environmental_necessities
@@environmental_necessities[self.type]
end
end

36. Raise

37. class Aircraft
def start_engine
# try to start the engine
raise "Unable to start engine" unless @engine.started?
end
end

38. class Aircraft
def deploy_landing_gear
# try to deploy the landing gear
return @landing_gear.deployed?
end
end

39. class Aircraft
def deploy_landing_gear
# try to deploy the landing gear
# landing gear is stuck halfway through
raise "Prepare for crash landing" if @landing_gear.stuck?
return @landing_gear.deployed?
end
end

40. rules to raise

41. begin
# some calculations
# some network io
# some file io
# some magic
rescue => e
logger.error('Run! Run! we have an error!')
end

42. begin
# some calculations
# some network io
# some file io
# some magic
rescue => e
logger.error "Just logging! don't look at me like that."
raise
end

43. begin
# some calculations
# some network io
# some file io
# some magic
rescue ZeroDivisionError
# handle the zero devision exception
rescue SomeCrazyException
# handle the crazy exception
rescue => e
logger.error "No idea what's heppening. I'm just going
to retry in a while. #{e.message}"
end

44. Blind rescue missions

45. name = @user.first_name ? @user.first_name.capitalize : "Anonymous"

46. name = @user.first_name.capitalize rescue "Anonymous"

47. random facts
rescue => e
doesn’t rescue Exception
it only rescues StandardError

48. *args/hash

49. def accepts_var_args(*args)
planet = args[0]
no_of_moons = args[1]
moons = args[2..(no_of_moons + 1)]
continents = [(no_of_moons + 2)..-1]
end

50. large number of
parameters

51. hash as the last
argument

52. class Person
def teach(arguments)
arguments[:student].accept_skill(skill(arguments[:skill]))
end
end
# 1.8.x
yoda.teach(:student => luke, :skill => "lightsaber")
# 1.9.2
yoda.teach(student:luke, skill:"lightsaber")
# VS
yoda.teach(luke, "lightsaber")

53. while we are talking
about the options hash

54. do not

55. modify options hash

56. or even worse

57. and expect invoker to
fetch data out of it post
call

58. it leads to the dark side

59. def activate_skynet(options)
options[:instructions] = "Eliminate John Conner"
uri = "https://sky.net/activate".to_uri
uri.post(options[:auth_headers])
end
options = {"Authentication" => "Basic: XXXXXXXXXXX"}
activation_status = activate_skynet(options)
next_step = options[:instructions]

60. private methods

61. readability

62. encapsulation

63. cleaner API

64. class BabelFish
def translate(some_sound, to_language)
# code for
# detecting the language
# of the text
# code for
# converting the input sound
# into text
# code for
# generating text
# in target language
# code for
# convertin text
# to speach in to_language
end
end

65. class BabelFish
def translate(sound, to_lang)
from_lang = detect_language(sound)
from_text = convert_to_text(from_lang,sound)
to_text = translate_text(from_lang, to_lang, from_text)
return text_to_speach(to_text, to_lang)
end
private
def detect_language(sound)
# some code
end
def convert_to_text(language,sound)
# some code
end
def translate_text(from, to, text)
# some code
end
def text_to_speach(text,language)
# some code
end
end

66. then why not?

67. probably they don’t
belong here

68. what’s the alternative?

69. class BabelFish
def translate(sound_data, to_language)
Sound.new(sound_data).to_text.translate(to_
language).to_sound
end
end
class Sound #:nodoc:
# code
end
class Language #:nodoc:
# code
end
class Script #:nodoc:
#code
end

70. Class#new as factory

71. new is just a method

72. can work as a factory

73. few things to keep in
mind

74. return the same type

75. don’t return nil

76. don’t raise an
exception

77. http://blog.sidu.in/2007/12/rubys-new-as-factory.html

78. class methods

79. where is my object?

80. general belief
static methods are
BAD

81. can’t inherit

82. can’t be abstract

83. can’t be polymorphic

84. hard to test

85. threading issues

86. does the rule of thumb
apply to Ruby?

87. ruby class methods are
not static

88. Ruby class methods are
way more elegant &
powerful

89. class Foo
def self.say
p "#{self.name} says hi"
end
end
class Bar < Foo
end
Foo.say #=> "Foo says hi"
Bar.say #=> "Bar says hi"

90. class Foo
def self.say
p "#{self.name} says hi"
end
end
class Bar < Foo
def self.say
super
p "and welcomes you to ruby conf"
end
end
Foo.say #=> "Foo says hi"
Bar.say #=> "Bar says hi" n "and welcomes you to ruby conf"

91. easy to test

92. ActiveRecord::Base.find

93. methods on instance of
a class Class

94. def self.# not so bad

95. as long as it belongs

96. class Company
def sort_emplyees(all_employees)
all_employees.sort_by(&:salary)
end
end

97. metaprogramming

98. random facts
alias_method
creates a deep clone of a
method it’s not equivalent to
delegate

99. conclusion

100. try new things

101. be nice to people
who’ll inherit your
code

102. write tests

103. 42
Aakash Dharmadhikari Niranjan Paranjape
http://twitter.com/aakashd http://twitter.com/niranjan_p
https://github.com/aakashd https://github.com/achamian