No Types Needed, Just Callable Method Check

RubyKaigi2026 Day2 Sub Arena

Transcript

1. No Types Needed, Just Callable Method Check Daichi Kamiyama @_dak2_ 2026-04-23 RubyKaigi 2026
2. About Me
3. ˒ Daichi Kamiyama ˒ https://github.com/dak2 ˒ https://x.com/_dak2_ ˒ Software Engineer at Timee,Inc. @dak2
4. Timee,Inc.
6. This talk in one line “In the age of AI, maybe we only need to check that a method is callable, at least in Ruby.”
7. Outline
8. ˒ The benefits of types ˒ How AI changed development experience ˒ Introducing my solution - `Method-Ray` - ˒ The difference from existing type checkers ˒ Future Outlook
9. Part 1 The benefits of types
10. Writing types
11. Writes RBS::Inline in my company
12. RBS::Inline & Steep
15. Writing types on a daily basis
16. Type ecosystem
17. ˒ RBS ˒ RBS::Inline ˒ Sorbet ˒ Tapioca Ruby’s type ecosystem is thriving ˒ Steep ˒ TypeProf ˒ etc…
18. Why write types? Including annotations
19. What are the benefits of types?
20. Documentation
23. ˒ Url is String ˒ Payload is Hash has title and body ˒ Return is Response
24. Types are living docs
25. Focus on I/F
27. Think interface first
28. Contract
30. Explicit boundaries between modules
31. Type Error Prevention
33. Catch type errors before execution
34. Types are constraints and guardrails
35. Part 2 How AI changed development experience
36. Generative AI has changed development experience
37. Generative AI got dramatically better at writing programs
38. Of course, it's not perfect, since it’s non-deterministic
39. AI is getting better at writing Ruby code
40. Deploy-ready code has increased with minimal reviews
41. Hold on, I realized,,,
42. AI quality keeps climbing
43. Type ops cost is real
44. Last-mile typing is difficult
45. Are types needed in the AI era?
46. They can write deploy ready code even without types
48. Ruby, Python, and JavaScript were the fastest, cheapest, and most stable
49. https://arxiv.org/pdf/2412.20545
50. LLM generation success rate inverts with task scale
51. Type safety improves, but code quality degrades
52. 🤔
53. Types are constraints and guardrails for humans
54. But, some types are needed
55. Types as a contract
56. Other types are not needed
57. However, they do something non- deterministic
58. So, guardrails are needed for AI
59. The main benefit I gain from writing types is preventing `NoMethodError`
60. 🧐
61. What if I could prevent `NoMethodError` — without writing any types?
62. Part 3 Introducing my solution `Method-Ray`
63. `Method-Ray` is a gem
65. Just check callable methods
66. ❌ No inferred type display ❌ No type error reports ❌ No nil-safety warnings ❌ No generic variance checks ❌ No LSP / editor integration Nothing else.
67. So, this just prevents `NoMethodError`
68. “Do one thing and do well” — Unix Philosophy
69. I/F is Ruby, But core logic is Rust
70. Interface: 1 command
71. Let’s see it in action
73. Architecture
74. Ruby Code ruby-prism AST Installer Scan Graph Output
75. Parse Ruby code using ruby-prism crate
76. Ruby Code ruby-prism AST Installer Scan Graph Output
77. Using arena allocator using bumpalo crate Parsed Ruby code
78. Copy source bytes into the arena Parse Ruby code using ruby-prism crate API
79. Why Arena is fast ? Heap alloc (slow) A B C D E F scattered u per-node alloc/free u syscall overhead Arena alloc (fast) A B C D E F bump pointer contiguous u bump pointer u drop entire arena once No per-node free. Throw the whole arena away in one operation.
80. Walks AST nodes and builds graph Ruby Code ruby-prism AST Installer Scan Graph Output
81. ASTInstaller has global and local env Global env has RBS definition Maps AST nodes to graph operations
82. Handles by node type recursively
83. Call install_class
84. Enter Class scope, register constants, methods, etc..
85. user.rb 1 class User 2 def initialize (name) 3 @name = name 4 end 5 6 def greet 7 "Hello, #{@name} !" 8 end 9 end Initialize greet name / @name init "Hello, #{@name}"
86. Register user-defined methods
87. Register methods from RBS definition
88. MethodRegistryɾO(1) Lookup HashMap<(ReceiverType, MethodName), MethodInfo> ("String", "length") → MethodInfo { return: Integer } ("String", "upcase") → MethodInfo { return: String } ("Array", "first") → MethodInfo { return: T? } ("User", "greet") → MethodInfo { return: String } ("User", "initialize") → MethodInfo { params: [name: String] } Lookup = single hash, regardless of project size
89. Tracks how types flow between expressions via edges Ruby Code ruby-prism AST Installer Type Graph Output
90. Type Graph in Action Source x = 1 y = x y .foo Graph flow flow call 1: Int x y y.foo MethodCall Each expression = Vertex. Edges carry type info forward.
91. MethodCallBoxɾReactive Constraint Frame 1 x = "hello" x .length box checks: String#length ✓ OK Frame 2 x = 42 ← reassign x .length x's type changes! type: Integer (box subscribed to type) Frame 3 // box re-runs x .length on Integer box checks: Integer#length ✗ NoMethodError No manual re-run. The box subscribes to the receiver — when type changes, it re-fires automatically.
92. ChangeSet · Atomic Edge Updates Without batching edge_a.add(T1) // trigger reaction edge_b.add(T2) // trigger reaction edge_c.add(T3) // trigger reaction ⚠ inconsistent intermediate states With ChangeSet changes.queue(edge_a, T1) changes.queue(edge_b, T2) changes.queue(edge_c, T3) changes. apply() // all at once ✓ single consistent snapshot Boxes re-execute on the final state, not every intermediate.
93. Detect methods in User class `floor` method is not found
94. Walks the method resolution order chain and returns the first match
95. Method Resolution Order via RBS 1. User Class ← Nothing 2. String ← Nothing 3. Module ← Nothing 4. SuperClass ← Nothing 5. Object ← Nothing 6. Kernel ← Nothing ✗ TypeError method not found
96. Collects errors and formats diagnostics with source locations Ruby Code ruby-prism AST Installer Type Graph Output
97. Source Location, End to End Source app.rb:12:30 AST Node SourceLocation { line:12, col:30 } MethodCallBox carries location Diagnostic app.rb:12:30 // Output app.rb:12:30 error: undefined method `floor' for String puts User.new("Alice").greet.floor We never drop position info. Every node, every box, every diagnostic carries it.
98. Parse => Graph => Scan => Output
99. Why Rust?
100. High performance
101. CLI performance is especially important in this era
103. Oxc is a set of JavaScript tools created by voidZero
104. Oxlint is JavaScript linter of Oxc tools, 50~100x faster than ESLint
105. https://readoss.com/en/oxc-project/oxc/inside-oxlint-linter-architecture-and-rule-system
106. Optimization of Oxlint is so interesting
107. The existence of Prism's Rust bindings is another key factor
108. Seeking fast CLI
109. Part 4 The difference from existing type checkers
110. Steep Sorbet TypeProf Method-Ray Approach Validates code against RBS signatures Flow-sensitive type checking Abstract interpretation Graph-based type inference Annotations Required (.rbs) Required (inline sig) Not required Not required
111. Part 5 Future Outlook
112. Currently, it's not production-ready at all yet
113. 1. Multiple file analysis
114. 2. Handle gem rbs
115. 3. Handles pre-defined RBS files
116. Conclusion
117. Are types needed in the AI era? What do you think?
118. Thank You!