Commit | Line | Data |
720accfe |
1 | ---- |
2 | presentation_topic: meta meta meta meta |
3 | presentation_title: Object Meta Programming |
4 | presentation_place: YAPC::EU::2007 |
5 | presentation_date: Aug 29, 2007 |
6 | ---- |
7 | = HAI FRENDS |
8 | {image:http://personal.inet.fi/taide/junttila/desert/2002/promopi.jpg} |
9 | == My name is Yuval |
10 | ---- |
11 | = Meta Programming |
12 | {image: http://www.prints.co.nz/Merchant2/graphics/00000001/7104_Squares_with_Concentric_Circles_Kandinsky_Wassily.jpg} |
13 | ---- |
14 | = Introduction |
15 | {image: http://www.room101.net/door.jpg} |
16 | +* Meta programming |
17 | +* writing /code/ which /outputs/ or /manipulates/ /code/ |
18 | ---- |
19 | = Many forms |
20 | {image: http://www.internationalhero.co.uk/m/manimal.jpg} |
21 | +* string `eval` |
22 | +* `%::` |
23 | +* closure generators |
24 | +* macros |
25 | +* real macros |
26 | +* compilers |
27 | ---- |
28 | = Many forms |
29 | {image: http://www.junjan.org/weblog/images/Flying_Spaghetti_Monster-thumb.jpg} |
30 | +* Home grown snippets |
31 | +* Home grown packages |
32 | +* Stuff on the CPAN (e.g. `Class::Accessor`, `Code::Perl`) |
33 | +* Large systems (`Template::Toolkit`) |
34 | ---- |
35 | = Summary |
36 | {image: http://www.evc.org/programs/TD_web_projects/westside_amy_2003_1/teen_times/peerpressure/images/16_peer_pressure_smoking.gif} |
37 | * You should already know it |
38 | * You probably do it |
39 | +* That's the intended audience anyway ;-) |
40 | ---- |
41 | = Object Meta Programming |
42 | ---- |
43 | = Object Meta Programming |
44 | +* Code that outputs or manipulates /object oriented code/ |
45 | +* Often written in OO |
46 | ---- |
47 | = Simple Examples |
48 | {image: http://www.wildoats.com/content/ApplePieSlice.jpg} |
49 | +* `Class::Accessor`, `Class::InsideOut` |
50 | +** Generates accessor methods |
51 | +* `Class::Prototyped` |
52 | +** Prototype object support in Perl |
53 | +* Lots of stuff on the CPAN |
54 | ---- |
55 | = Modeling OO |
56 | {image: http://www.nordicsubs.co.uk/covers/vogue.jpg} |
57 | +* High level object meta programming |
58 | +** The current trend |
59 | +** The picture illustrates an object modelling with class =) |
60 | +** Seriously though... |
61 | ---- |
62 | = Modeling OO |
63 | {image: http://www.nordicsubs.co.uk/covers/vogue.jpg} |
64 | * High level object meta programming |
65 | * What is a class? |
66 | +.vim |
67 | filetype: perl6 |
68 | |
69 | class Class { |
70 | has @isa; |
71 | has %methods; |
72 | has %attributes; |
73 | |
74 | ... |
75 | } |
76 | .vim |
77 | ---- |
78 | = Modeling OO |
79 | {image: http://www.nordicsubs.co.uk/covers/vogue.jpg} |
80 | +* Implementing OO |
81 | +** In OO |
82 | +* Meta objects: |
83 | +** Class |
84 | +** Method |
85 | +** Attribute |
86 | ---- |
87 | = Example class |
88 | |
89 | .vim |
90 | filetype: perl6 |
91 | |
92 | class Point { |
93 | has $x; |
94 | has $y; |
95 | |
96 | method distance_to { ... } |
97 | } |
98 | .vim |
99 | ---- |
100 | = Modeled with objects |
101 | |
102 | .vim |
103 | filetype: perl |
104 | |
105 | Class->new( |
106 | attributes => [ |
107 | Attribute->new( name => '$x' ), |
108 | Attribute->new( name => '$y' ), |
109 | ], |
110 | methods => [ |
111 | Method->new( |
112 | name => "distance_to", |
113 | definition => sub { ... } |
114 | ), |
115 | ], |
116 | ); |
117 | .vim |
118 | ---- |
119 | = Metamodel Services |
120 | {image: http://www1.istockphoto.com/file_thumbview_approve/944779/2/istockphoto_944779_reception_bell.jpg} |
121 | +* Form |
122 | +** Introspection/Reflection |
123 | +* Function |
124 | +** Class generation |
125 | +** Class transformation |
126 | +* Pattern packaging |
127 | ---- |
128 | = Case Study |
129 | {image: http://www.iinteractive.com/moose/images/a_moose.gif} |
130 | == Moose |
131 | +* A deep meta object system |
132 | +* 4 layers deep |
133 | +** Syntactic sugar |
134 | +** Custom metaclasses |
135 | +** Class::MOP |
136 | +** Perl's native OO |
137 | ---- |
138 | = Perl's native OO |
139 | {image: http://www.mileslight.com/images/perl-camel.gif} |
140 | +* Minimalistic |
141 | +** Class = Package = Symbol table hash |
142 | ** Inheritence tree embedded in `@ISA` entry |
143 | ** `bless` links data to a class |
144 | ** `->` |
145 | +* Insanely flexible |
146 | +* Pretty klunky |
147 | +* Written in C (not very accessible) |
148 | ---- |
149 | = Class::MOP |
150 | {image: http://nothingmuch.woobling.org/MOP.jpg} |
151 | +* port of CLOS, more or less |
152 | +* MOP = Meta Object Protocol |
153 | ---- |
154 | = Class::MOP |
155 | {image: http://nothingmuch.woobling.org/MOP.jpg} |
156 | +* Model |
157 | +** `Class::MOP::Class` |
158 | ** `Class::MOP::Method` |
159 | ** `Class::MOP::Attribute` |
160 | +* Easy interface |
161 | +** Introspection |
162 | +** Transformation |
163 | ---- |
164 | = Class::MOP |
165 | {image: http://nothingmuch.woobling.org/MOP.jpg} |
166 | +* Can "parse" packages into meta objects |
167 | +* Modifying the objects writes back to packages |
168 | +* Code generation |
169 | +** Accessors from attributes |
170 | +** Constructor from attributes |
171 | +** Method modifiers |
172 | ---- |
173 | = Moose's custom metaclasses |
174 | {image: http://www.iinteractive.com/moose/images/a_moose.gif} |
175 | +* Subclasses of `Class::MOP::Class` et al |
176 | +* More fun features |
177 | +** Roles |
178 | +** `BUILD` etc a la Perl 6 |
179 | +* Type constraints |
180 | ---- |
181 | = Moose sugar layer |
182 | {image: http://nothingmuch.woobling.org/sugar.jpg} |
183 | +* Pseudo-declarative syntax |
184 | +* Maps to metaclass manipulations |
185 | +.vim |
186 | has foo => ( is => "rw" ); |
187 | .vim |
188 | +* becomes |
189 | +.vim |
190 | $metaclass->add_attribute( |
191 | Moose::Meta::Attribute->new( |
192 | foo => ( is => "rw" ), |
193 | ) |
194 | ); |
195 | .vim |
196 | ---- |
197 | = Moose vs. Class::Accessor |
198 | {image: http://nothingmuch.woobling.org/p-seal-at-toronto-zoo.jpg} |
199 | +* All that bloat just for the `has` syntax? |
200 | +* *NO!* |
201 | +* Pattern packaging |
202 | ---- |
203 | = MooseX:: |
204 | {image: http://www.threadpit.com/photos/all_styles/small/401.jpg} |
205 | +* Packaged meta code |
206 | +* Pretty clean |
207 | +* Mostly composable |
208 | ---- |
209 | = MooseX:: |
210 | {image: http://www.threadpit.com/photos/all_styles/small/401.jpg} |
211 | +* `MooseX::Storage` |
212 | +** Customizable serialization through metaprogramming |
213 | +* `MooseX::AttributeHelpers` |
214 | +** Additional methods for collection type attributes |
215 | +* `MooseX::Getopt` |
216 | +** Additional constructor compiles attributes into a `Getopt` spec |
217 | +* `MooseX::IOC` |
218 | +** Inversion of control integrated into the object system |
219 | ---- |
220 | = The point of Moose |
221 | {image: http://nothingmuch.woobling.org/cute_moose.jpg} |
222 | +* OO is less tedious |
223 | +* Helps you write meta code |
224 | +** Good APIs promote clean code |
225 | +** Easier to build on existing base |
226 | +** Conventions and structure let you play well with others (`MooseX::`) |
227 | +** Introspectable & tranformable metamodel |
228 | ---- |
229 | = Another Case Study |
230 | {image: http://www.rockies-ice.com/images/MainHeaderPic_5.gif} |
231 | == ORMs |
232 | +* Are *HARD* |
233 | +* Not even fun like the picture |
234 | ---- |
235 | = ORMs |
236 | {image: http://www.agiledata.org/images/legacyDataSources.jpg} |
237 | +* Modeling |
238 | +** Tables <-> Classes |
239 | +** Fields <-> Attributes |
240 | +* Code Generation |
241 | +** SQL |
242 | +** Accessors |
243 | +** Relationship fetchers |
244 | ---- |
245 | = `Class::DBI` |
246 | +* Meta code is in the base class |
247 | +* No clear schema modelling |
248 | +* No separation between regular & meta code |
249 | +* Lots of hacks |
250 | +* Don't go there |
251 | ---- |
252 | = `DBIx::Class` |
253 | +* Meta enlightened |
254 | +** Schema objects fully model the SQL side |
255 | +** ResultSource etc partially model the OO side |
256 | +** Components for everything |
257 | ---- |
258 | = `DBIx::Class` |
259 | +* Meta code: |
260 | +** Proxy objects |
261 | +** Accessors |
262 | +** Code generation (SQL, Perl) |
263 | ---- |
264 | = ORM related meta programming |
265 | +* Complex |
266 | +* But manageable |
267 | ---- |
268 | = Vaporware |
269 | {image: http://www.nzgeothermal.org.nz/geothermal_energy/images/big/b-silencer-water-vapour.jpg} |
270 | ---- |
271 | = MO |
272 | {image: http://www.nzgeothermal.org.nz/geothermal_energy/images/big/b-silencer-water-vapour.jpg} |
273 | +* My baby |
274 | +* Moose spinoff |
275 | +** Stevan says it's Moose 2.0's |
276 | +* Perl 5 & Haskell (in pugs) |
277 | ---- |
278 | = MO Sucks |
279 | {image: http://www5f.biglobe.ne.jp/~tantan-kids/I.syokuzai/lollypop.jpg} |
280 | +* Experimental code |
281 | +* Boring parts messy or unwritten |
282 | +* Lacking integration, sugar layer |
283 | +** mst promised to help ;-) |
284 | +* Some parts slow as $*!&% |
285 | ---- |
286 | = MO Rocks |
287 | {image: http://nothingmuch.woobling.org/rocks.jpg} |
288 | +* Purely functional |
289 | +* Very suited for meta transformations |
290 | +* Fine grained control over everything |
291 | +* Can introduce entirely new conceptions of OO |
292 | ---- |
293 | = MO Architechture |
294 | {image: http://www.narrabay.com/images/engineering_large.jpg} |
295 | +* Modeling layer |
296 | +** Corresponds to compilation |
297 | +* Responder layer |
298 | +** Corresponds to runtime |
299 | ---- |
300 | = MO Architechture |
301 | {image: http://www.narrabay.com/images/engineering_large.jpg} |
302 | +* Compiler/sugar layer creates the modeling layer |
303 | +** Class objects are constructed, with all the details |
304 | +** No meta calculations happen yet |
305 | +* Modeling layer is "compiled" into responder layer |
306 | +** Can be done on demand or upfront |
307 | +* Obscurely named objects |
308 | +** Bear with me |
309 | ---- |
310 | = "Concepts" |
311 | {image: http://gallery.hd.org/_exhibits/light/_more2003/_more05/light-bulb-glowing-filament-light-blue-uncropped-lores-3-AHD.jpg} |
312 | +* The purest form of OO is prototypes |
313 | +** prototype OO can implement class OO |
314 | +* Concepts are new ways to express objects |
315 | +* A class is a concept |
316 | +* A role is a concept |
317 | ---- |
318 | = "Responder Interfaces" |
319 | {image: http://www.cs.usfca.edu/~parrt/course/652/lectures/images/vtable.jpg} |
320 | +* `$ri->dispatch( $responder, $invocation )` |
321 | +* Generated from concepts |
322 | +* Abstract VTable |
323 | +** The flattened method hierarchy |
324 | +** ... or something completely different |
325 | +** Performance |
326 | +** Flexibility |
327 | ---- |
328 | = "Responders" |
329 | {image: http://www.maine.gov/spo/flood/images/fema_seal.gif} |
330 | +* Something that is the subject of invocations |
331 | +** An object instance |
332 | +** A class (class methods) |
333 | +* A simple tuple `( $data, $ri )` |
334 | ---- |
335 | = "Invocations" |
336 | {image: http://www.mobilenews.sk/wp-content/lg-banana.jpg} |
337 | +* A method call, multimethod, message... whatever |
338 | +** Arguments, too |
339 | +* Whatever an RI will put up with |
340 | +** Extensible calling semantics |
341 | ---- |
342 | = MO compilation flow |
343 | {image: http://www.daveltd.com/photo/rolls/digital/water/waterfalls/snoqualmie-falls/snoqualmie-falls-flowing-3811-equalized.jpg} |
344 | +* Instantiate a `Class` object |
345 | +** Specify members (methods, attributes) |
346 | +** ... and ancestor classes & roles |
347 | +* Compile class |
348 | +** `my $class_methods_ri = $class->class_interface()` |
349 | +** Instance method RI closed in the constructor, within `$ri` |
350 | +** Purely functional operation |
351 | ---- |
352 | = RI composition |
353 | {image: http://www.daveltd.com/photo/rolls/digital/water/waterfalls/snoqualmie-falls/snoqualmie-falls-flowing-3811-equalized.jpg} |
354 | +* Compute instance methods and attributes from ancestry |
355 | +* Compute instance slots from attributes |
356 | +* Generate accessors |
357 | +.vim |
358 | MO::Run::ResponderInterface::MethodTable->new( |
359 | methods => %methods |
360 | ); |
361 | .vim |
362 | +* Generate constructor |
363 | +.vim |
364 | sub { |
365 | my $data = process_params(@_); |
366 | return box( $data, $instance_ri ); |
367 | } |
368 | .vim |
369 | ---- |
370 | = Instantiation |
371 | {image: http://d6044171.u109.worldispnetwork.com/images/Creation-hands-L.jpg} |
372 | +* Lookup RI using class name |
373 | +* Dispatch constructor class method |
374 | +* Compose data from params |
375 | +** Slightly complicated |
376 | +* Link data with closed `$instance_ri` |
377 | +** Responder == ( Data, RI ) |
378 | +** Like `bless` |
379 | ---- |
380 | = Method calls |
381 | {image: http://www.w3.org/2005/Talks/05-maxf-xtech/telephone.jpg} |
382 | +* How to talk with your new object? |
383 | +.vim |
384 | my $ri = $responder->responder_interface; |
385 | |
386 | |
387 | + my $method = MO::Run::Invocation::Method->new( |
388 | name => "foo" |
389 | arguments => \@blah, |
390 | ); |
391 | |
392 | |
393 | + $ri->dispatch( $responder, $method ); |
394 | .vim |
395 | +* Arbitrary responder interfaces also allowed |
396 | +** Doesn't have to be `$responder->responder_interface` |
397 | ---- |
398 | = OH NOES!!! |
399 | {image: http://www.encyclopediadramatica.com/images/f/f5/Surprise-buttsecks.jpg} |
400 | +* What's wrong with the previous slide? |
401 | +* RIs are objects too! |
402 | +* Need to bootstrap method calls |
403 | +* Runtime must bootstrap low level OO |
404 | +** More on this soon |
405 | ---- |
406 | = Meta level polymorphism |
407 | {image: http://www.worth1000.com/entries/44500/44790qV87_w.jpg} |
408 | +* An important point |
409 | +** In fact, *the* point of MO |
410 | +* Responder interfaces are polymorphic |
411 | +** Method table, network proxy, whatever |
412 | +* Easy to specialize |
413 | +** Optimizations |
414 | +** Strange features |
415 | +* Easy to mix several OO systems |
416 | +** Just compile to separate RIs |
417 | ---- |
418 | = MO in Perl 5 |
419 | {image: http://www.vetaid.org/assets/shop/card-camel-108.jpg} |
420 | +* Two runtimes |
421 | +* Very different |
422 | +* `MO::Run::Aux` wraps both |
423 | +** Share tests by running with different `%ENV` var |
424 | ---- |
425 | = Hosted runtime |
426 | {image: http://www.philnjill.com/collections/kubricks/kub_alien/S2Secret.jpg} |
427 | +* Nested object system |
428 | +* Bootstraps with Perl 5 |
429 | +** Native Perl OO == Low level, like VM opcodes |
430 | +** Virtualized MO == High Level |
431 | +** Completely separate levels |
432 | +* `$ri->dispatch( $responder, $method )` |
433 | +** not `$responder->$method()` |
434 | +* Full expressiveness |
435 | +* Slow, verbose |
436 | ---- |
437 | = Native runtime |
438 | {image: http://www.sonofthesouth.net/american-indians/pictures/indian-camp.jpg} |
439 | +* Integrated object system |
440 | +* RIs are compiled into packages |
441 | +** Simple RIs are dissassembled and stuffed into the stash |
442 | +** Complex RIs use `AUTOLOAD`, delegating to the RI meta object |
443 | +* Only named method calls |
444 | +** No arbitrary call concepts |
445 | +** `->` doesn't support anything else |
446 | +* As fast as "regular" Perl OO |
447 | +** Even makes simple, standalone `.pmc`s |
448 | ---- |
449 | = Perl 5 Runtimes |
450 | +* Native |
451 | +** Usable with regular Perl OO {html:☺} |
452 | +** Lacks arbitrary invocations {html:☹} |
453 | +* Virtualized |
454 | +** Feature complete {html:☺} |
455 | +** Doesn't integrate {html:☹} |
456 | +** Slow {html:☹} |
457 | ---- |
458 | = Idealized MO toolchain |
459 | {image: http://www.ibiblio.org/wm/paint/auth/botticelli/botticelli.venus.jpg} |
460 | +* Compiler handles modeling |
461 | +** Constructs meta objects at compile time |
462 | +* VM Opcodes support standard RI |
463 | +* Custom RIs are just objects |
464 | +** Bootstrapped using standard runtime objects |
465 | +*** Method table RI |
466 | +*** Named method invocation |
467 | ---- |
468 | = Perl 6 |
469 | {image: http://lolgeeks.com/wp-content/uploads/2007/05/lolgeeks016.jpg} |
470 | +* Perl 6 is the idealized MO toolchain |
471 | +** Can introduce syntax |
472 | +*** Invocation types |
473 | +*** Concept declarations |
474 | +** Implement bootstrap RIs in VM opcodes |
475 | +* Pugs might be using MO |
476 | +** I'm not really sure |
477 | +** It was ported a while ago |
478 | ---- |
479 | = Introducing new concepts |
480 | +* Roles are the shit |
481 | +* But what about next week's fad? |
482 | +* MO lets you introduce a new concept |
483 | +** Arbitrary at compile time |
484 | +** RI protocol at runtime |
485 | ---- |
486 | = Example - Prototype Objects |
487 | +* One shared RI |
488 | .vim |
489 | sub dispatch { |
490 | my ( $object, $invocation ) = @_; |
491 | |
492 | my $method = $object->{ $invocation->name }; |
493 | |
494 | $object->$method( $invocation->arguments ); |
495 | } |
496 | .vim |
497 | ---- |
498 | = Example - Attribute Grammars |
499 | {image: http://nothingmuch.woobling.org/village_people.jpg} |
500 | +* Crazy stuff from the 1970s |
501 | +* Renewed interest in {html:λ} land |
502 | +* Was pretty easy in MO |
503 | ---- |
504 | = Attribute Grammer Implementation |
505 | {image: http://grammar.ccc.commnet.edu/grammar/images/grammar.gif} |
506 | +* Introduce new concept objects |
507 | +** Attribute Grammar |
508 | +** Attribute Grammer Instance - one per AG per class |
509 | +* Runtime specialized RI |
510 | +** Shadows any RI with additional context sensitive methods |
511 | +* Additional runtime support code |
512 | ---- |
513 | = MO TODO |
514 | {image: http://www.constructionownerslawblog.com/checklist.jpg} |
515 | +* Write a sugar layer |
516 | +** Make it fun to use |
517 | +* Tests |
518 | +* Refactor the Class objects |
519 | +** Bloated example code |
520 | +** There are some patterns to extract |
521 | +* Self hosting |
522 | ---- |
523 | = Self Hosting |
524 | +* Easier to maintain MO written in Moose |
525 | +* Need to have clean syntax |
526 | +* Stable `.pmc` compilation |
527 | ---- |
528 | = Conclusion |
529 | {image: http://www1.istockphoto.com/file_thumbview_approve/2540021/2/istockphoto_2540021_painted_exclamation_mark.jpg} |
530 | +* Meta code is awesome code |
531 | +** Especially my meta code ;-) |
532 | ---- |
533 | = Conclusion |
534 | {image: http://www1.istockphoto.com/file_thumbview_approve/2540021/2/istockphoto_2540021_painted_exclamation_mark.jpg} |
535 | * Meta code is awesome code |
536 | +** Lets you program in new ways |
537 | +** Helps you take care of your other code |
538 | +* Meta code is important code |
539 | +** It can affect *anything* |
540 | +** Keep it minimalistic, and clearly defined |
541 | +** No spaghetti monsters |
542 | +* Meta code can be simple |
543 | +** Only complicated if you aren't careful |
544 | ---- |
545 | = BIE FRENDS |
546 | {image: http://www.girlscoutsofblackhawk.org/Portals/0/webphotos/thanks.jpg} |