Web Development and Perl 6
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 611 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/42426 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language | ||
| Production Year | 2017 |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FOSDEM 2017226 / 611
10
14
15
16
17
21
22
24
25
27
31
36
40
42
46
50
55
56
63
70
73
78
84
94
101
102
104
107
108
109
110
111
112
113
114
115
117
119
122
123
126
127
128
130
131
132
135
136
137
138
141
142
144
145
146
150
151
157
158
159
160
162
163
164
166
170
171
173
175
176
177
179
181
184
187
189
191
193
194
199
200
205
207
208
209
211
214
218
219
222
223
224
225
226
229
230
232
234
236
237
238
239
245
248
249
250
251
253
255
257
258
259
260
261
264
265
266
267
268
271
272
275
277
279
280
282
283
284
287
288
290
292
293
297
302
304
305
306
307
309
310
311
312
313
314
316
317
318
319
321
322
327
329
330
331
333
336
338
339
340
341
346
348
349
350
352
354
356
358
362
363
364
367
371
372
373
375
380
384
385
386
387
388
389
390
391
392
393
394
395
398
400
401
402
405
407
409
411
412
413
416
417
418
420
424
425
427
428
429
431
435
438
439
440
441
443
444
446
448
454
459
460
461
462
465
466
468
471
473
477
478
480
483
487
488
489
491
495
498
499
500
501
502
503
504
507
508
510
511
512
514
518
519
520
522
524
526
528
530
531
533
535
536
549
550
554
555
558
560
563
564
573
575
578
579
582
585
586
588
589
590
591
592
593
594
595
596
600
603
604
605
609
00:00
Web-DesignerBlogMusical ensembleXML
00:33
Modul <Datentyp>Interior (topology)LoginMultiplicationDatabaseString (computer science)Programmable read-only memoryActuaryUltimatum gameQuiltWebsiteWeb pageComputer programmingArchaeological field surveyBitFormal languageCodeWeb 2.0Parameter (computer programming)Functional (mathematics)Semantics (computer science)MathematicsOptical disc driveConnected spaceSoftware frameworkResultantCartesian coordinate systemElectronic mailing listDevice driverOnline helpRevision controlTemplate (C++)MereologySoftware developerModule (mathematics)ImplementationCategory of beingRepository (publishing)Server (computing)Stability theoryMiddlewareBlock (periodic table)Web-DesignerProxy serverDatabaseTheoryComputer-generated imageryVideo gameString (computer science)Multiplication signDependent and independent variablesLine (geometry)Level (video gaming)LoginDemo (music)Web applicationComputer fileObject (grammar)Exception handlingDebuggerKnowledge-based configurationProper mapRoutingSinc functionInterface (computing)HookingRootMatching (graph theory)Front and back endsFraction (mathematics)BlogMultilateration
09:32
Raster graphicsServer (computing)Context awarenessString (computer science)Error messageSign (mathematics)Cartesian coordinate systemPasswordRight angle
10:14
MereologyBlock (periodic table)Element (mathematics)Server (computing)PermianInterior (topology)Computer wormLoginContext awarenessScalar fieldFormal languageObject (grammar)CodeVariable (mathematics)Profil (magazine)Slide ruleCross-platformContext awarenessSystem callDirectory serviceType theoryFunctional (mathematics)Electric generatorPlanningCodeClosed setHookingModule (mathematics)Software developerParameter (computer programming)Electronic mailing listCoroutineElement (mathematics)Codierung <Programmierung>Block (periodic table)Compilation albumMultiplication signHash functionElectronic signatureComputer programmingBitStatement (computer science)MereologyWeb pageTemplate (C++)Level (video gaming)VolumenvisualisierungDefault (computer science)Pulse (signal processing)BenchmarkCartesian coordinate systemSinc functionError messageSource codePoint (geometry)Video gameCASE <Informatik>Programmer (hardware)WordStandard deviationComputer fileAxiom of choiceDifferent (Kate Ryan album)Capability Maturity ModelContext-sensitive languageGoodness of fitRevision controlCompiler5 (number)XML
18:28
Pairwise comparisonVolumenvisualisierungTemplate (C++)PlastikkartePrice indexFree variables and bound variablesHash functionCodeOperator (mathematics)Object (grammar)Template (C++)WebsiteResultantSheaf (mathematics)LaptopMultiplication signString (computer science)Computer programmingPower (physics)MereologyComputer fileKey (cryptography)Block (periodic table)Formal grammarSpacetimeData structureProjective planeOpen setError messageProper mapRun time (program lifecycle phase)Control flowData bufferSystem callRegulärer Ausdruck <Textverarbeitung>Patch (Unix)BenchmarkFluid staticsRoutingCartesian coordinate systemCache (computing)Variable (mathematics)ParsingDifferent (Kate Ryan album)Pairwise comparison2 (number)Row (database)Computer fontSingle-precision floating-point formatConstructor (object-oriented programming)
26:34
Game controllerGroup actionMultiplicationModul <Datentyp>Block (periodic table)Server (computing)Pairwise comparisonLine (geometry)MereologyInterior (topology)Module (mathematics)Block (periodic table)Attribute grammarSingle-precision floating-point formatType theoryMultiplication signPopulation densityPoint (geometry)CodeWeb 2.0Formal languageSlide ruleAsynchronous Transfer ModeWater vaporNumberBitSubject indexingLine (geometry)Task (computing)Network socketJava appletFunctional (mathematics)Revision controlGoodness of fitArc (geometry)PressureParallel portSocial classBoundary value problemComputer architectureCartesian coordinate systemGroup actionComputer fileContext awarenessEmoticonUnicodeWeb pageElectronic mailing listMeasurementConcurrency (computer science)CurveControl flowVolumenvisualisierungStructural loadObject (grammar)Projective planeWrapper (data mining)MathematicsNormal (geometry)Direction (geometry)View (database)Software frameworkStatisticsProcess (computing)Error messageWeb applicationBoilerplate (text)Moore's lawException handlingConnectivity (graph theory)DatabaseWeb-DesignerGame controllerProper mapWindowOverhead (computing)Right angleComputer animation
34:40
Computer animation
Transcript: English(auto-generated)
00:00
Okay, so the room seems to settle down quite nicely, so we may as well start. A couple months ago, I think it was in October, Louder! Whoa!
00:21
I already did all my shouting on Friday in the beer event, so... But I will try. Okay, a couple months ago, I guess it was in October, I stumbled across a blog post about web development with Pro 5, and it started like this. Even though I'm in the thralls of Pro 6,
00:41
I still do all my web development in Pro 5, because the ecology of modules is so mature. When I read this sentence, it kind of rubbed me the wrong way. Here's someone who clearly likes Pro 6, yet cannot use it for what he needs to be doing, and to me, that's kind of unacceptable.
01:03
I just refuse to believe that after so many people poured so much time into Pro 6, it should still not be ready for something as mundane as web development. So I set out on my quest to show that this sentence is misguided, or just plain obsolete.
01:24
So, where do we begin? How do we show that everything is not as bad as this blogger believes? Well, I did a little survey of modules.prol6.org, and had a look at everything that at least sounded like a web framework to me.
01:41
These are the results. As you can see here, it's a reasonably short list. In itself, that's not that bad. The list of actively developed web frameworks for Pro 5 is probably not that much longer. Of course, there are lots and lots and lots of failed attempts or abandoned frameworks on CPAN.
02:07
This raises the second question. To which category do these belong? To answer this question, I had a look at the date of the last commit to the repositories.
02:21
Now, keep in mind that the very first stable release of Pro 6 as a language was in December 2015. And in the couple of months before this release, we really rushed in a lot of semantic changes that we knew we had to get in before we were ready to commit to a stable version of the language.
02:43
So everything that has not seen any commits in these months or afterwards is probably a bit rotted or really incredibly lucky. For example, webapp Ballet claims that it's going to be merged with Baillador in the near future.
03:10
I got curious and had a look about when the sentence was added to the documentation. Any guesses?
03:22
It's not that bad. It's March 2013. It hasn't happened yet. I'm not sure if it will ever happen. But with this filter applied, we are left with three contenders. No, no, no. Let's not jump to conclusions here. Three can still be a very decent pool to choose from.
03:44
We'll just have a look. The first one is Crust. Crust is in short a PSGI implementation in Pro 6. It's a glue between the web server and the web framework itself.
04:00
It lets us centralize code for supporting different ways of connecting our application to a web server like fast CGI or being run behind the front-end proxy. Though certainly very useful, it's probably not the very first thing that you'll be looking for. But let's keep it in mind for now. We'll come back to it later.
04:25
Web can be considered one level above Crust in the stack. It gives you request and response objects and the dispatcher. Not luxurious, but sounds like at least a good start. Except for that it apparently does not even support fancy newfangled features like file uploads.
04:49
And there's another thing missing that I'd consider a somewhat essential part. And then we'll come back to this later. For now let's move on to the first thing that you should have considered.
05:02
Bailador is pretty much a very straightforward port of Dancer to Pro 6. It is lightweight. It is being actively developed, though somewhat slowly. And it brings much of what you would expect from a web framework. It's a little thin on the documentation and on examples.
05:23
But since it's a very straightforward port of Dancer, I could just implement the Dancer tutorial example application in Bailador. Just to see how well it does. The program I'm talking about is kind of a minimalistic block.
05:41
You can log in, block something insightful, and this gets then displayed on the front page. Now Bailador does not come with any kind of built-in configuration system. So first off I wrote an extremely sophisticated one, which you can see here.
06:00
Well, at least it lets me stick very closely to the original example. Now, here's a bit of database setup code. It's nothing special. Though I have to mention that I very much like how DBI-ish uses named parameters instead of parsing some obscure connection string.
06:20
Though it's kind of odd that the SQLite driver doesn't cope too well with being given a proper IOPath object. So I have to stringify the path before giving it. But okay. Now, if you know a bit of Dancer, you're going to feel right at home here. This is pretty much the same as you would write in Perl 5.
06:43
We define a route for our GET requests to the root and give Bailador a code block to execute when the route matches. Again, DBI-ish interface looks quite a bit cleaner than good old DBI to me. That's the advantage of being able to start over with a fresh new code base.
07:06
The login handler seems to be a good example for how to access parameters, sessions, and redirects. Very straightforward, easy to use, very familiar from Dancer. So, have I convinced you yet that Perl 6 is absolutely ready for web development?
07:27
Who of you noticed the little interesting bit in the last line here? Instead of just calling the template function as you would do in Dancer, I passed the result to a function called layout.
07:40
Why is that? Well, Bailador simply hasn't seen as much development as Dancer or much delicious. So again, it has no built-in support for layout templates or hooks. So I had to write a little helper. Nothing bad, really.
08:00
There's also no facility to construct URIs yet. So for now, our little example application cannot be run with a path prefix. And this is also a part that I consider very much missing from web. Again, probably not a deal breaker. It just shows that Bailador is not as mature a framework as Dancer or much delicious.
08:27
Now wait a minute. Do you remember Crust, the PSGI framework for Perl 6? Well, the cool thing about PSGI is that it allows for sharing so-called middlewares between applications and frameworks.
08:42
There are tons of middlewares, from support for running behind a frontend proxy to awesome debug panels and I don't know what else. So in theory, you could have the same with Crust, but middlewares have yet to appear.
09:01
Nevertheless, Crust is certainly a good base. So we may as well give it a try. The documentation makes this look much more complicated than it actually is. This tiny PSGI file is all that's needed to bring Crust and Bailador together. So we could give it a try.
09:23
As I have much extra time, I can do a little live demo here. Okay, it starts. That's a good sign. And the application is running. Nice.
09:44
So yeah, that's it. We can go forward, be heroes, write awesome middlewares. But first off, I'm going to show you the login thingy.
10:05
Oh no, wait. Now you're seeing my super secret password. Oh, well this is the error message.
10:30
You know, everyone has a point where she just gives up. The question is only where exactly this point is. And it will probably depend on if you're just playing around with this like I have,
10:44
or you need to earn some hard currency with this. So is there no hope? Are we really stuck with the choice between a mature ecology of modules and the devotion to our new love? Well, screw it. I want to have both.
11:03
If Dancer 2 is where the development is and the features are, then Dancer 2 I will use. Now this is kind of like the canonical Hello World example in Dancer 2, taken straight out of its tutorial.
11:21
Damn it. Okay, it's probably updated by now, but okay. It's probably not looking that much different. Okay, but if I were to try this, it would explode again. And why is that? Well, the documentation doesn't tell you this, but Dancer 2 actually passes the application object to your handler routine.
11:47
Since Prol 6 does have proper subroutine signatures integrated into the language, it expects you to declare those parameters that are passed to your code. So it would rightfully complain that no parameters were declared, but passed in any way.
12:04
So what could we do to make Prol 6 happy? We could do it like this. We declare the parameter, but this is undocumented and it would be tedious and look less pretty. And we cannot have that, can we?
12:22
Now luckily, Tachik, who first tried this, found a really pretty way around that. In Prol 6, code blocks are not just syntactic elements, but first-class objects. You can think of subroutines as code blocks with explicit signatures.
12:41
Naked code blocks have a default signature that is used to create the topic variable, dollar underscore. And one argument is exactly what we need to get around this. Now let's have a look at how well we do at the original Dancer example I ported to Belador.
13:04
I'm not going to show you the full source code, that would mostly just be boring code like this. Interesting bits may be to point out that I do stick with the tutorial closely, so I use Prol 5's DBI and template toolkit.
13:21
Also, one of the little improvements of Prol 6 that matters so much, at least to me in my daily life as a programmer, is that we have file specs functionality integrated into the language. So we can just use the tempdir variable and its convenient child method for platform-independent generation of the path to a good temp directory.
13:48
As I mentioned, I just use DBI, which all of you should know, really. So this will look very familiar to you, but also a little strange. First of all, there's no undef anymore. Even undefined values are typed in Prol 6.
14:08
So the closest thing to a plain undef is an undefined any, which is what I passed to the connect method here. Now, what the hell is this dollar hash thingy? Any ideas?
14:31
It's an itemized hash. It's a hash that should be treated like a single item, and that's the most important part, not interpolated into the argument list of the method call.
14:45
It's a bit like taking a reference in Prol 5, except that we don't have references anymore, or that everything is by reference, depending on the way you look at it. Lastly, this code shows how to access global Prol 5 variables in Prol 6, which is exactly like in Prol 5 itself.
15:09
If you try this at home and it doesn't work that way, you have a version of inline Prol 5 installed that's been written before this weekend. Just to let you know.
15:22
The old way was not as pretty, and I just hate showing things that are not pretty in my slides, so I had to fix it. On to a more mundane piece of code, the before template render hook. As you probably know better than me, this is just a sub that gets passed a hash into which it can set some values.
15:45
Now please, a quick show of hands. How many of you people have forgotten this semicolon after the closing curly in code like this? It happens to me all the time in Prol 5, which is why I'm so glad that Prol 6 has fixed this for us.
16:05
You don't need it anymore. The compiler is smart enough to guess what you actually meant. The statement ends there. Now this is the heart of our program. The code that actually delivers the page.
16:22
The one specialty here is this map thingy. Now, what's that? Well, when we pass a hash from Prol 6 to Prol 5, what the thing in the background
16:42
does is it ties a Prol 5 hash so all the access is redirected to the Prol 6 hash. Now if this sounds slow, you're spot on. It's so slow that it's very visible in benchmarks. Now a map is an immutable hash.
17:02
And since it's immutable, since we know it cannot ever be changed anymore, we get by with just copying it to a plain Prol 5 hash. So this is much faster, and Lancer accesses this hash a lot. So this is a little way to really speed it up.
17:25
The final piece of Lancer code I'm going to show is this bit. There's nothing out of the ordinary here. In fact, it's actually a little bit closer to what the Lancer documentation suggests than the tutorial itself. I'm talking about using the body parameters.
17:44
I think you call it keywords. Yeah. Other than this being the recommended way anyway, there's a reason for this deviation. And this reason is the param keyword is context sensitive. It behaves different in list context than in scalar context.
18:03
Now this is a tricky bit of the language that Prol 6 doesn't have anymore. There's no distinction between call contexts anymore. So there's also no way to communicate to the Prol 5 function in which context it is called.
18:21
So what we do is we call every function in list context, because it's the most general one. In almost every case, it will just plain work. Now, yeah, as I said in Prol 6, we don't have this distinction anymore. Now, all this switching between Prol 5 and Prol 6 must surely cost a lot of performance.
18:44
But how much? Well, I benchmarked the little block application and found that it's actually doing quite fine. 170 requests per second on my laptop is surely enough for many websites. In fact, I think most websites out there see far less traffic than that.
19:03
For comparison, I tried the same with Bellador and was quite stunned. I didn't expect stellar performance, but 240 milliseconds for a simple website like that, for a single request, that's kind of embarrassing, really.
19:22
I was sure that I have made some mistakes, so I dug a little into it. And I found out that TemplateMojo, which Bellador uses, uses a Prol 6 grammar to parse the templates, and Prol 6 grammars are not fast. What it does then is it generates Prol 6 code and then evals this code.
19:46
Now, no one ever expected Prol 6 to compile fast. It's a humongously complex language, and we're working hard on getting it fast at runtime, but compile time is way much beyond that.
20:04
So doing this double parse for every single request is pretty much the slowest thing you could do. The good news is that it's fixable, and it's trivially fixable. I mean, you just have to cache the generated subroutine. And TemplateMojo actually has such a cache, but Bellador uses it in a way that it cannot use it,
20:25
because it generates a new template object every request. It's fixable, it's quite simple, it's just a symptom of Bellador and Prol 6 being relatively new.
20:41
Next, I had a look at Motrilicious. As Motrilicious is quite similar to Dancer, the results were quite similar as well. So instead of a boring introduction, I will just focus on a couple of stumbling blocks I discovered when porting all the tutorial examples.
21:02
This hello world should be pretty much exactly what you expected. As it happened to me, just note this space before the sub and before the opening parenthesis. If you leave out the space in there, and I should have used another font to make it more clear,
21:25
Prol 6 will think that you will want to call a sub called sub. And give you a very confusing error message about $c not being declared. But other than that, if you do it correctly, it just works like this.
21:42
Now, it would be really cool if this example worked as shown. Because Motrilicious supports storing templates and static files in the data section of your program. But Prol 6 doesn't have this data file handle.
22:06
Instead, this is integrated into parts. So we have the finish part command, which just tells it, well, Prol 6 stopped here. The rest is, yeah, data. Now, as I have a little extra time, I can do a little side story.
22:22
This does not work yet. But just a question to the audience, how would you implement this? In Prol 5, we have this magic data file handle. And in Prol 6, we have, well, a part command.
22:42
Any ideas? Well, my first thought would be, yes, okay, we probably have to create this file handle. Probably give it a memory buffer. Now, one of the nice things about Prol 6 is that we have lots and lots of introspection features.
23:03
So you can also actually, very simply, access all the parts in your program from within the program. There are magic variables, like dollar equals finish contains all the data.
23:21
So, we have to create a file handle backed by a string, and we have a string. So why have I not yet implemented this? I hate showing things that don't work. Now, it turns out the really tricky part is the timing. Because you have this Use Motulicious Lite from Prol 5 up there.
23:46
This is where Motulicious is loaded from Prol 5. This is where all the initialization code runs. It's a begin time, because Use is a begin time construct. The finish part command has not even been parsed yet.
24:05
So, I'm not sure where exactly to put it in the program flow. If any of you have any idea about this, I'd be glad. So, what you do to get around this is you put this in a proper template file.
24:25
Which is what you should do anyway. At least to get the proper syntax highlighting for this code. When I prepared the example to show how to give a route a name, I stumbled over another subtle difference between Prol 5 and Prol 6.
24:45
In Prol 6, the fat comma operator I use up there, is no longer just a fancy way to spell a comma. It's an operator that creates a pair object. A pair is just a key in the value.
25:02
Now, if you chain those fat commas, you create a nested pair structure with a pair that has another pair as a value. And MochaLicious gets quite confused if it sees that. So, instead of having another fat comma there just because it looks pretty,
25:21
just use the comma. Now, this is the very first example that really, really doesn't work. Because right now it's unfortunately impossible to pass a regular expression from Prol 6 to Prol 5. I actually have a patch that implements the support.
25:44
I just need to clean it up and finish it. Unfortunately, it would still not be enough. Because what MochaLicious does is it takes this regular expression, it stringifies it, and then includes the string inside another regular expression for a dispatch.
26:01
And the way I implemented the support is to create a Prol 5 regex that really just has a code block inside, which can then delegate to the Prol 6 regex, which tells it should you match or not. And this code block, of course, does not stringify to anything sensible. So, I think there's a way around it.
26:23
I have found ways around any of the problems I had so far, but it's going to take some time. What does work, on the other hand, is WebSockets. And I just can't help but find this incredibly cool.
26:41
And if you look at this, there's really nothing special you have to do. It just works like this, like Documented. Now, for something that looks a bit different than the last three frameworks, Catalyst is an interesting candidate. Catalyst puts a bit more pressure on you to stick to an MVC architecture.
27:01
It automatically loads your module view and controller modules. And, of course, it expects those to be written in Prol 5. It even gets a step further and generates a boilerplate code for you. And this is code that we probably better leave just as it is,
27:21
so I won't waste much time on it. The far more interesting question is, how do we get our Prol 6 code into there? The answer is by declaring that the rest of the file is written in Prol 6. Everything from the use v6 inline line up there is just plain old Prol 6 code.
27:44
We have an index method with appropriate Catalyst attributes, making the method a Catalyst action. Of course, we get past the context object and we can call methods on it. And we can use the usual methods to get our job done.
28:04
This pretty much works out of the box, except for the Catalyst attributes. I was quite surprised that Stephen Little did not come up with this example for attributes, because it's the place where I've seen them used most.
28:20
Like I said, in Prol 6 we don't have subroutine attributes. We have traits instead. Now, traits can, for example, be a convenient way to add a role to a method object, and even methods like code blocks and everything else are really proper objects in Prol 6.
28:43
For a Catalyst action, we want to mix in the inline Prol 5, Prol 5 attributes role, because I suck at naming. And because I suck at naming, this role provides an attributes attribute, which is just a list of attributes to apply to the Prol 5 wrapper,
29:05
that gets generated for inline Prol 6 methods. Now, this little helper method, the CatalystXProl6ComponentProl5 attributes, contains two more trait mode functions for supporting the arcs and action class attributes,
29:25
but they look pretty much exactly like this code. So, that's it. And this is really all you should have to know and use to be able to use Catalyst in a Prol 6 project. Which is quite cool.
29:41
And now, I know what's been bothering me about the sentence that haunted us so far. It just takes two really tiny changes for me to be able to make peace with it. Because, even though it's certainly fun building a new web framework,
30:01
I sometimes just need the reliable tools I know and am so familiar with. And luckily, they're still there for me. Now, the question which I haven't touched yet is, why would I want to? Why would I want to leave the familiar territory and venture forth into the unknown?
30:23
Well, for some the answer would be, exactly! Because that's what I want to do. I want to explore. Well, some will be attracted by the opportunity to carve out a name for yourself, to become the Sebastian Riedel for the Prol 6 world.
30:42
Others will simply feel that Prol 6 as a language is incredibly well suited for web tasks. For example, thanks to emoticons, Unicode is huge right now. And Prol 6 is at the forefront of Unicode. And of course, having the gradual type support, Prol 6 covers a sweet spot between
31:09
type support that catches so many stupid errors we all make. But not too much type support so it would get in the way like I experienced with Java and web development, which sucks.
31:25
And of course, having good parallelism and concurrency support in the language lets us finally move into this day and age regarding the use of our computing power. So, while the solutions I've shown you today will not get you there immediately,
31:42
they will be a good first step into that direction. Thank you. Any questions, please?
32:11
There's at least one question that I'm extremely surprised that does not come. Do you know whether Prancer is still a thing? Prancer? Ah, the name rings a bell but it must be so old.
32:30
I haven't seen him talk about it for quite a while so it's probably somewhere out there. I just want to have the stack trace you've gotten by the door, please. Later, maybe.
32:45
I want to fix it, you know? Yeah, that's great. Maybe you could paste the whole thing. Yeah, I can certainly do, yeah. The question I'm surprised that I've not heard is, I've shown some performance statistics somewhere.
33:09
Yeah, we have Dancer 2 via Perl 6 and Bailador. But how does it compare to the original Dancer in Perl 5? The reason why I haven't put it up in the slide is that I don't have the exact numbers anymore.
33:25
I somehow forgot to write them down. But I seem to remember that the Perl 6-ish version is about 4.7 times slower than the original Perl 5 version. Which sounds like a lot, but on the other hand, one or two milliseconds per page window is not that bad.
33:46
The example is very small and we're measuring probably almost only the overhead. And in a normal web application you would do much more than just do a single database query with two results and render them in a trivial way.
34:07
I guess 4.7 times slowdown is the upper boundary of what you would see. But someone will have to write a larger application, so we'll know it.
34:20
Please. Yes, that's a good question. Any other questions? Then we may have a short break. Thank you.