The document discusses the necessity of creating programming languages and highlights Smalltalk's implementation on Rubinius as a solution to current programming challenges. It includes technical details about the Rubinius compiler, code examples, and the design philosophy behind it. The content reflects on the limitations of existing languages and the importance of creativity in programming.

1. Smalltalk On
Rubinius
Konstantin Haase

10. Why implement
Smalltalk on Rubinius?

11. Why create a
programming language?

12. Why create?

13. "When you don't create things, you become
defined by your tastes rather than ability. Your
tastes only narrow and exclude people. So
create."
why the lucky stiff

14. Why a programming
language?

15. About programming languages:
"I don’t like any of them, and I don’t think any of
them are suitable for the real programming
problems of today, whether for systems or for
end-users"
Alan Kay

16. Problem Oriented
Programming Languages
Cairo (~120k SLOC in C) rewritten in less than
400 lines

17. Why Smalltalk?

18. Why Rubinius?

20. 1 + 1
1 + 1

21. this is it
this.is.it

22. GoGaRuCo rock: #hard
GoGaRuCo.rock :hard

23. doc convertFrom: #xml to: #yaml
doc.convert(:xml, :ruby)

24. doc convertFrom: #xml to: #yaml
doc.convert from: :xml, to: :ruby

25. [ 42 ]
proc { 42 }

26. anArray do: [ :each | each doSomething ]
an_array.each do |element|
element.do_something
end

27. Textmate version = 2
ifTrue: [ 'no way' ]
ifFalse: [ 'thought so' ]
if Textmate.version == 2
"no way"
else
"thought so"
end

28. Storage current
store: #foo;
store: #bar
storage = Storage.current
storage.store :foo
storage.store :bar

29. Smalltalk claims to look
like: 'English'.
Judge yourself. Does it.
Ruby.claims.to.look.
like "English"
Judge.yourself; Does.it?

30. Reak
github.com/rkh/Reak
Like Squeak but with R
File based (as opposed to image based)

32. The Rubinius Compiler
Pure Ruby
Modular and Flexible
lib/compiler

34. Parsing with KPeg
github.com/evanphx/kpeg

35. " from Reak.AST.Self "
grammar: g [ ^ g str: 'self' ]
# from Reak::AST::Return
def bootstrap_grammar(g)
g.seq "^", :sp, g.t(:expression)
end

36. Rubinius Bytecode

37. $ rbx compile -B -e 'puts "Hello World"'
0000: push_self
0001: push_literal "Hello World"
0003: allow_private
0004: send_stack :puts, 1

38. $ rbx compile -B -e 'puts "Hello World"'
0000: push_self
0001: push_literal "Hello World"
0003: allow_private
0004: send_stack :puts, 1

39. $ rbx compile -B -e 'puts "Hello World"'
0000: push_self
0001: push_literal "Hello World"
0003: allow_private
0004: send_stack :puts, 1

40. $ rbx compile -B -e 'puts "Hello World"'
0000: push_self
0001: push_literal "Hello World"
0003: allow_private
0004: send_stack :puts, 1

41. $ rbx compile -B -e 'puts "Hello World"'
0000: push_self
0001: push_literal "Hello World"
0003: allow_private
0004: send_stack :puts, 1

42. class Object
dynamic_method(:display) do |g|
g.push_self
g.push_local(0) # first argument
g.send(:puts, 1, true)
g.ret
end
end
display "Hello World"

43. Reusing the Rubinius
tool chain

45. class Reak::Compiler < Rubinius::Compiler
class Parser < Stage
stage :parser
next_stage Generator
end
end

46. class CustomNode < Reak::AST::Base
def self.bootstrap_grammar(g)
# grammar definition
end
def bytecode(g)
# bytecode definition
end
end

47. class ConstantAccess < Rubinius::AST::ConstantAccess
include Reak::AST::Node
Reak::AST::Primary.push self
def self.bootstrap_grammar(g)
g.t /[A-Z][a-zA-Z0-9_]*/
end
# no bytecode definition necessary
end

48. Rubinius.AST.TrueLiteral subclass: #TrueLiteral [
Reak.AST.Primary push: self.
self include: Reak.AST.Node.
self class >> grammar: g [
^ g str: 'true'
].
]

49. " Remember cascades? "
g
pushSelf;
pushLocal: 0;
send: #puts args: 1 private: true;
ret.

50. Reak.AST.Base subclass: #Cascade [
Reak.AST.Expression push: self.
bytecode: g [
g pushSelf.
cascadedSends do:
[:send |
g dup.
send bytecode: g.
g pop ].
lastSend bytecode: g.
]
]

51. Thanks!
github.com / rkh / presentations