building dsl s in static & dynamic languages

Transcription

1 ThoughtWorks building dsl s in static & dynamic languages NEAL FORD thoughtworker / meme wrangler ThoughtWorks 14 Wall St, Suite 2019, New York, NY nford@thoughtworks.com memeagora.blogspot.com

2

3 what i cover motivation types of dsls building dsls in: java groovy ruby external dsls best practices

4 burning questions why is there so much xml mixed in with my java code? why do things like aspects exist? why won t everyone shut up already about ruby on rails? is there an evolutionary step beyond objectoriented programming?

5

6

7 2.days.from.today Superclass Superclass Subclass Subclass Subclass Subclass Subclass Subclass objects, aspects, generics become the building blocks for dsls

8 declarative vs imperative code

9 why dsls? Iced Decaf Triple Grande Vanilla Skim with whip latte. Scattered, smothered, covered Route 66, swinging, easy on the chorus, extra solo at the coda, and bump at the end OMFG D00d Bob is t3h UBER 1337 R0XX0RZ LOL waffle house hash brown language: scattered, smothered, covered, chunked, topped, diced, peppered, & capped

10 Every non-trivial human behavior has a domain specific language.

11 including your job all businesses have their own dsl why developers tend to stay within domains how non-developers talk about work

12 nomenclature coined by martin fowler domain specific language a limited form of computer language designed for a specific class of problems language oriented programming general style of development which operates about the idea of building software around a set of domain specific languages

13 definitions domain specific notation terminology specific to a particular logical domain (related to ubiquitous language) domain specific language a limited form of computer language designed for a specific class of problems

14 api: explicit context

15 dsl: implicit context Venti half-caf, non-fat, extra hot, no foam, no whip latte once context is established, repeating it over and over is just noise

16 text without context is pretext. jesse jackson

17 types: internal aka embedded sit atop a base language why dynamic languages tend to make better bases

18 types: external build your own language must be able to lex and parse your language let your imagination run wild!

19 a word about patterns

20 Internal DSLs

21 fluent interface treat lines of code as sentences example: jmock expectation

22

23 car api

24 car fluent interface as simple as writing set methods that return this

25 method chaining Make modifier methods return the host object so that multiple modifiers can be invoked in a single expression.

26 example: logging writing a fluent interface around log4j properties file creation

27 the target

28 dsl syntax

29 alternate syntax

30

31 expression builder a layer that provides a fluent interface over a regular api

32 wrapping api s wrap existing api s in fluent interfaces to improve readability example: wrapping ibatis

33 ibatis xml configuration

34 sqlmap

35 ThoughtWorks

36

37 bakery life competition is brutal! incentives to encourage repeat customers......but the other guys do the same thing flexible business rules easy to define & change

38 establishing profiles

39 discounts

40 customer profile fluent interface pojo stuff

41 profile in action

42 discount

43 discount implementation

44 getdiscount()

45 rule list

46 demo, part 1

47 demo, part 2

48 chained result

49 rule list

50 result

51 the finishing problem when does the call finish? make sure things happen at the right time?

52 method invocation chained method calls nested method calls

53

54

55 mitigating the finishing problem build fluent interfaces with a mixture of chained and nested method invocations

56 use method chaining for stateless object construction

57 use nested methods to control completion

58 good citizenship? building objects with chained methods can create bad citizens validation on dependent method calls in the nested add() method imposes order semantics allows invalid state

59 testing

60 context & noise

61 providing context....

62 what kind of rocket science?

63

64 dynamic building blocks closures open classes dynamic typing looser syntax rules than java

65 the goal

66 expando meta-class

67 expando property

68 open classes for recipes

69 recipe redux

70 of why grams & not lbs?

71 of redux

72 who returns what? BigDecimal Ingredient Integer Ingredient

73 type transmogrification transform types as needed as part of a fluent interface call

74 ruby

75 Recipes

76 target syntax

77 open classes open class alias method

78 killing noise characters

79 const_missing

80 expression builder building a simple language for recipes allows you to build other stuff underneath for example, a nutrition profile

81 recipe nutrition profile

82 nutrition profile

83 testing profile

84 context

85 add context evaluates ruby code by switching self to the instance of the object calling instance_eval

86 context

87 switching contexts

88 declarative advantages declarative code reveals semantic intent imperative code reveals implementation dsl s allow you to specify intent without coupling in implementation

89

90

91

92

93

94

95 external dsl

96 roll your own language create your own parser & lexer lex/yacc

97 antlrworks

98 antlrworks

99 language workbenches a tool that supports language oriented programming intentional software (charles simonyi) software factories (microsoft) mps (jetbrains)

100 compilation since cs-101 Parse Compile class Foo { private int id; } Editable Representation Storage Representation Executable Representation

101

102 post- ide s first java ide to edit the abstract syntax directly enables refactoring

103 workbenches Versioning Storage class Foo { private int id; } Workbench Projections Document Window Tab Tab Tab Label Menu Editable Label Text Representation Field Storage Representation Label Text Field Text Field Text Field Label Text Field Text Field Text Field Executable Representation

104 jetbrains mps

105

106 envision the perfect result what is the ideal dsl syntax? build towards it the rake napkin

107 test, test, test

108 narrow the problem domain keep your dsl as cohesive as possible create solutions by composing dsls......not creating more complicated languages jetbrain s use of mps

109 domain specific languages improve abstractions by eliminating noise

110 ...whose time is coming a better way to solve some problems...

111 ThoughtWorks questions? please fill out the session evaluations slides & samples available at nealford.com NEAL FORD thoughtworker / meme wrangler ThoughtWorks This work is licensed under the Creative Commons Attribution-Noncommercial-Share Alike 2.5 License Wall St, Suite 2019, New York, NY nford@thoughtworks.com memeagora.blogspot.com

112 resources upcoming book on building internal dsl s in ruby zak tamsen & dan manges