The document summarizes a presentation given on refactoring code to domain-specific languages (DSLs) in Scala. It provides an example of refactoring shell command execution code in Java into a DSL in Scala using techniques like implicit conversions and infix notation. The presentation argues that by applying Scala idioms carefully, code can be naturally refactored into a DSL tailored to the problem domain, providing a simple way to migrate code from Java to Scala.

1. Scala LiftOff Recap and Refactoring to DSLs by David Orme Eclipse, Rich web, and Scala consulting [email_address] Presented to Chicago Area Scala Enthusiasts CASE

8. People made suggestions/improvements

9. Sessions were voluntarily merged

12. Enterprise adoption: Status and opportunities

13. Killer applications / uses

14. Thinking in functions

16. Enterprise adoption: Status and opportunities

17. Killer applications / uses

18. Thinking in functions

20. Paid off technical debt – eliminated implementation duplication throughout the library

21. Consistent implcit conversions to and from Java collections and Scala collections

23. def resize(width: Int, height: Int) = { ... }

24. resize(width = 120, height = 42) resize(height = 42, width = 120)

26. def f(elems: List[Int], x: Int = 0, cond: Boolean = true)

27. f(List(1))

28. f(Nil, cond = false)

30. import scala.util.control.Breaks._

31. breakable {

32. for (x <- elems) {

33. println(x*2)

34. if (x > 0) break

35. }

36. }

38. Brand new, much more stable Eclipse plugin.

39. Tight Java tooling integration

40. No more ”Project/Clean” or closing/reopening projects to reboot the compiler!

41. Same tool support also ported to NetBeans

42. Martin definitely ”gets it” about the importance of having high quality Scala tool support

44. 2.8 could be what causes Scala to cross the chasm into the mainstream

46. Enterprise adoption: Status and opportunities

47. Killer applications / uses

48. Thinking in functions

50. Facebook

51. RTM

53. Clarify

54. Swiss Quote

55. (some smaller financial firms)

58. Often a DSL of some form

60. Someone to sue

62. Yes, some people still say this, even in 2009!

64. Enterprise adoption: Status and opportunities

65. Killer applications / uses

66. Thinking in functions

69. Content-management systems

72. Enterprise adoption: Status and opportunities

73. Killer applications / uses

74. Thinking in functions

76. A, A', A'', A''', … , A (n)

79. Notice how this helps with threading and concurrency!

83. -> Make sure that your load-balancing server uses sticky sessions (that the same session always goes to the same server)

86. Enterprise adoption: Status and opportunities

87. Killer applications / uses

88. Thinking in functions

92. Provides visible, incremental benefits

94. Translate the basic idea into Scala

95. Apply Scala idiom(s) to improve code

96. ”Can we do better?”

97. Lather, rinse, repeat...

100. -> List files in $install_dir; place into @files array

103. Run a shell command and return results

106. Apply Scala idiom(s) to improve code

107. ”Can we do better?”

108. Lather, rinse, repeat...

110. val folder = &quot;/home&quot;;

111. println(&quot;ls &quot; + folder)

113. Plan B: Is there a way to interpolate ANYTHING into a String using regular Java or Scala?

115. val folder = &quot;/home&quot;;

116. val formatter = new java.util.Formatter()

120. val folder = &quot;/home&quot;;

121. val formatter = new java.util.Formatter()

124. val folder = &quot;/home&quot;;

127. val folder = &quot;/home&quot;;

128. println(&quot;ls %s&quot;.format(folder))

129. println(&quot;ls %s&quot; format folder)

131. val folder = &quot;/home&quot;;

132. println(&quot;ls %s&quot;.format(folder))

136. val folder = &quot;/home&quot;;

137. println(&quot;ls %s&quot; substituting folder)

138. println(&quot;ls %s&quot; << folder)

139. Notice: We have now created a simple DSL for variable interpolation into strings.

143. Apply Scala idiom(s) to improve code

144. ”Can we do better?”

145. Lather, rinse, repeat...

148. Instantiate it

154. for (line <- &quot;ls&quot;.exec().split(&quot;&quot;)) {

155. println(&quot;-> &quot; + line)

156. }

158. &quot;ls&quot;.exec().split(&quot;&quot;).foreach { file =>

159. println(&quot;=> &quot; + file)

162. Is there an operator that could reasonably mean ”execute” to a String?

164. Pro: We now have a reasonable ”backtick” operator, and a lot of OO/FP flexibility as well.

167. Run a shell command and return results

171. &quot;/home/djo&quot;.list.foreach(println(&quot;=> %s&quot; << _) )

174. -> Wrap repetitive Java code in ”bridge classes”

175. -> When appropriate, make those ”bridge classes” available via implicit conversions

176. -> Carefully use operator overloading

178. This provides us with a simple, repeatable migration path off of Java, onto Scala

180. Presentation available on SlideShare