The document discusses the programming language Ruby, highlighting its historical background, features, and comparisons to Lisp and other languages. It emphasizes Ruby's clean syntax, object-oriented nature, and powerful libraries, while also mentioning testing methodologies in the Ruby community. Additionally, it touches upon the importance of community and adaptability in the evolution of programming languages.

1. Ruby is
an acceptable Lisp
Vitaly Kushner
astrails.com

2. Ruby is better
then Lisp

3. Ruby is better
then Lisp
sometimes*
;-)

4. Language

5. http://www.flickr.com/photos/jantik/254695220/

6. Power

7. http://www.flickr.com/photos/lrargerich/4187318085/

8. Blub Language
Paradox
Paul Graham
http://paulgraham.com/avg.html

9. Is Lisp the most
powerful?

10. NO

11. It depends

13. • syntax

14. • syntax
• linguistic power

15. • syntax
• linguistic power
• domain

16. • syntax
• linguistic power
• domain
• libraries

17. • syntax
• linguistic power
• domain
• libraries
• community

18. Ruby

19. History

20. History
• Yukihiro Matsumoto (aka "Matz")

21. History
• Yukihiro Matsumoto (aka "Matz")
• Released in 1994

22. History
• Yukihiro Matsumoto (aka "Matz")
• Released in 1994
• Got known in US about 2000

23. History
• Yukihiro Matsumoto (aka "Matz")
• Released in 1994
• Got known in US about 2000
• Gained momentum around 2003-2005

24. more powerful
than Perl
more object-oriented
than Python.

25. Perl
Smalltalk
Eiffel
Ada
Lisp

26. • Simple consistent syntax
• Dynamically typed
• Late binding
• Single Inheritance with Mixin support

27. • Everything is an object
• Closures
• Garbage Collection
• Multi platform

28. Ruby is Awesome

29. Clean Syntax

30. var # variable
$var # global variable
@var # instance variable
@@var # class variable
CONST # constant
Class # class

31. attrs = {
:src => "foo.img",
:width => 100,
:height => 200,
:class => Avatar
}

32. User.find params[:id],
:limit => 10, :order => “name”

33. if @project.owned_by?(@user)
return false unless @user.admin?
end
@project.complete!

34. Higher-order
functions

35. Anonymous
functions

36. def x_times(x, fun)
for i in 1..x
fun.call(i)
end
end
x_times(10, lambda {|x| puts x})

37. def x_times(x)
for i in 1..x
yield i
end
end
x_times(10) {|x| puts x}

38. def x_times(x)
for i in 1..x
yield i
end
end
x_times(10) do |x|
puts x
end

39. Everything is
an Object
that you can extend

40. class Fixnum
def x_times
for i in 1..self
yield i
end
end
end
5.x_times { |x| puts x }

41. 5.times { |x| puts x }

42. map {|x| ...}
collect {|x| ...}
select {|x| ...}
reject {|x| ...}
find {|x| ...}
any? {|x| ...}
all? {|x| ...}
sort {|a, b| ...}

43. 3.megabytes
=> 3145728

44. 10.months.from_now
=> Thu Aug 12 03:25:40 0300 2010

45. 5.minutes.ago
=> Mon Oct 12 03:21:02 0200 2009

46. Closures

47. def incrementor(increment)
proc {|x| x + increment}
end
>> i5 = incrementor(5)
=> #<Proc:0x01874a78@(irb):46>
>> i5.call(3)
=> 8

48. Compact

49. # ruby
def paidMore(amount)
proc {|e| e.salary > amount}
end
// C#
public Predicate<Employee> PaidMore(int amount) {
return delegate(Employee e) {
return e.Salary > amount;
}
}

50. // ruby
def foo(n) lambda {|i| n+=i} end
; lisp
(defun foo (n) (lambda (i) (incf n i)))

51. # ruby
[1,2,3].map {|n| n*n }.reject {|n| n%3==1 }
; lisp
(remove-if (lambda (n) (= (mod n 3) 1))
(mapcar (lambda (n) (* n n))
'(1 2 3)))

52. Macros

53. Ruby fakes macros
pretty well

54. OO
+
Monkey Patching

55. class Person
def self.defsay(sound)
define_method("say_#{sound}") do
puts sound
end
end
defsay :hello
defsay :hi
end

56. >> bob = Person.new
=> #<Person:0x185cba8>
>> bob.say_hello
hello
=> nil
>> bob.say_hi
hi
=> nil

57. class Plugin < ActiveRecord::Base
validates_presence_of :name
validates_presence_of :description
validates_presence_of :author_id
belongs_to :author, :class_name => "User"
has_many :plugin_versions,
:dependent => :destroy
belongs_to :default_version,
:class_name => "PluginVersion"
acts_as_commentable
acts_as_taggable
...
end

58. Magic

59. NoMethodError

60. method_missing

61. User.find_by_name_and_company(
"Vitaly Kushner", "Astrails")

62. Ruby rewrite

63. require 'pp'
require 'parse_tree'
require 'parse_tree_extensions'
def print_ast(&block)
pp block.to_sexp
end

64. print_ast do
puts "hello"
end
s(:iter,
s(:call, nil, :proc, s(:arglist)),
nil,
s(:call, nil, :puts, s(:arglist, s(:str, "hello"))))

65. Multiple inheritance
is EVIL
:-)

66. Modules
a.k.a. Mixins

67. module FlyHome
def set_home
@home = position
end
def fly_home
fly(@home)
end
end

68. class Bird < Living
include FlyHome
def fly(direction) ...
def position ...
end
class Airplane < Machine
include FlyHome
def fly(direction) ...
def position ...
end

69. Libraries

70. Rubygems

71. ➜ ~ ✗ sudo gem install astrails‐safe
Successfully installed astrails‐safe‐0.2.7
1 gem installed
Installing ri documentation for astrails‐safe‐0.2.7...
Building YARD (yri) index for astrails‐safe‐0.2.7...
Installing RDoc documentation for astrails‐safe‐0.2.7...
➜ ~ ✗

72. Rubygems.org
12,798 gems

73. Github.com

74. Community
attitude

75. Testing

76. TDD

77. TDD
Test Driven Development

78. BDD

79. BDD
Behavior Driven Development

80. Pressure

81. TATFT

82. TATFT
Test All The Fucking Time

83. • Test::Unit
• RSpec
• Shoulda
• Cucumber
• Webrat

84. it "should be able to show media" do
@media = stub_media
Media.stub!(:find).and_return(@media)
get :show, :id => @media.id
response.should be_success
end

85. Ruby is Better
then Lisp
Q &A
Vitaly Kushner
astrails.com
@astrails @vkushner