02:30:51 <stepcut> http://happstack.blogspot.com/2011/11/ann-happstack-lite-friendly.html
03:29:09 <performance> stepcut: in general is there any templating system on any language/framework that can guarantee the validity of the transformed template?
03:30:02 <stepcut> a compile time guarantee?
03:32:26 <stepcut> oleg wrote some library that supposedly has combinators which can ensure validity:
03:32:26 <stepcut> http://okmij.org/ftp/Scheme/xml.html#typed-SXML
03:32:29 <stepcut> never tried it though
03:32:45 <stepcut> happstack has a built-in run-time validator you can turn on during debugging
03:33:16 <stepcut> with systems like heist or hamlet you can (at least in theory) validate the static portions of the templates at compile time. But the values you splice in could be funky.
03:34:03 <performance> stepcut: to serve templates we simple use the templateServe function:  s/simple/simply/c
03:34:50 <performance> well since you listed the lack of guarantee of validity in the two templating systems' cons section, i was wondering if that will appear in all the rest too :)
03:35:12 <stepcut> yeah, I have not finished that section yet
03:35:29 <stepcut> there are different levels of assurance as well, of course, well-formed vs valid
03:39:42 <stepcut> fixed, btw.
03:40:17 <performance> what are orphan instances?
03:41:45 <stepcut> performance: when declare type class instances you generally either declare the instance in the module you declare the type in, or the module that the 'class' declaration is in
03:42:04 <stepcut> that ensures that you can't import the type and the class with out also getting the instance
03:42:31 <stepcut> but let's say you declare the type in module A, the class in module B, and the instance in module C.
03:42:45 <stepcut> the instance in module C will be an orphan
03:42:55 <stepcut> if you import A and B, but not C, then you won't get the instance.
03:43:17 <stepcut> that can cause trouble if module D also declares the same instance
03:43:27 <stepcut> because if you try to import C and D, then you will get a conflict
03:43:43 <stepcut> performance: also, not sure if you saw, but I just released this, http://happstack.blogspot.com/2011/11/ann-happstack-lite-friendly.html
03:44:41 <performance> so why is it good to have warnings about those orphan instances suppressed?
03:49:34 <stepcut> performance: well. sometimes there is nothing you can do about it. and you get tired of hearing about it
03:55:10 <performance> :).
03:55:29 <performance> stepcut: any way my work is done for the day.. see you soon, bye
06:29:31 <jaspervdj> stepcut: digestive-functors-happstack- has happstack dependency bumped
22:40:52 <performance> stepcut: i finished reading through the crash course, and found some more typos, but over all it is really good :)
22:41:14 <stepcut> performance: nice!
22:41:38 <stepcut> performance: There are still a lot of sections missing, unfortunately, but the core technology is pretty well covered
22:41:40 <performance> after completing it and reading through the page for happstack-lite i have a few thoughts
22:41:52 <stepcut> excellent!
22:42:36 <performance> please dont take this the wrong way, even though i can program in Haskell i should consider myself a newbie, so my feedback should be taken with that in mind.
22:43:53 <stepcut> sure
22:44:17 <stepcut> I am am exceedingly not a newbie, which makes it hard for me to judge my own writing in that regards
22:44:51 <performance> basically the writing is excellent!
22:45:07 <performance> but the direction could be more newbie friendly
22:45:34 <stepcut> in both works?
22:45:36 <performance> for example, using a running example might help a lot!!
22:45:53 <stepcut> what do you mean by 'running example'?
22:46:18 <performance> essentially both crash course and lite just document what is available, and they do it in a very friendly way, but they just document it, they dont set it in a real world context
22:46:46 <stepcut> so, by running example, you mean, start building up a real world app?
22:47:05 <performance> in the old happstack tutorial there was a jobs site project, or the tutorial itself was the final project. [ i think wchogg and later thomas hartman were maintaining it]
22:47:14 <stepcut> right
22:47:42 <stepcut> That is what is supposed to come next in the tutorial
22:47:42 <performance> and going through that i got the sense of why i was doing some thing with the final goal and my progress towards it in context
22:48:16 <stepcut> the current part is supposed to be very useful as a reference. You wonder, "how do I do something" and you can go find a simple, self-contained example
22:48:29 <performance> Great:) i should say compared to the old tutorial the crash course has better visual appeal and better writing
22:48:37 <stepcut> :)
22:49:05 <performance> this looks visually like "learn you a haskell for great good :) "
22:49:33 <stepcut> but, I definitely want to do a higher level example where I show how to go through the process of designing a real app, and show why you might want to make certain choices, and how using web-routes will save you in the long run.
22:49:34 <performance> minus the funny examples and funny graphics :)
22:49:37 <stepcut> :)
22:49:47 <stepcut> I have never read learn you a haskell for great good, but I heard it is good
22:50:01 <performance> you should, even though you might be an expert,
22:50:02 <stepcut> I started using Haskell professionally in 2001
22:50:11 <performance> hehe way back
22:50:17 <stepcut> I have looked it a bit
22:50:24 <performance> oops, i have to restart my system, i will rejoin in a few minutes.
22:50:27 <stepcut> k