IRC log of dig on 2012-03-19

Timestamps are in UTC.

02:46:37 [rszeno]
rszeno has quit (Quit: Leaving.)
05:32:01 [cheater_]
cheater_ has quit (Quit: Ex-Chat)
05:34:05 [cheater_]
cheater_ (~cheater@ip-80-226-24-0.vodafone-net.de) has joined #dig
06:09:28 [github]
github (~github@sh2.rs.github.com) has joined #dig
06:09:28 [github]
[tabulator] presbrey pushed 1 new commit to master: http://git.io/zBLEbA
06:09:28 [github]
[tabulator/master] cleanup boiler plates - Joe Presbrey
06:09:28 [github]
github has left #dig
06:57:43 [cheater_]
cheater_ has quit (Ping timeout: 255 seconds)
07:17:16 [cheater_]
cheater_ (~cheater@p57AEBD96.dip.t-dialin.net) has joined #dig
10:22:32 [melvster]
melvster (~melvin@p5797F7C6.dip.t-dialin.net) has joined #dig
12:50:38 [rszeno]
rszeno (~rszeno@79.114.63.233) has joined #dig
12:59:26 [bblfish]
betehess: is a timbl() a unit of time such that one should wait no longer than it for a result? https://github.com/betehess/pimp-my-rdf/blob/master/linked-data/src/main/scala/LinkedDataMemoryKB.scala#L76
13:48:30 [bblfish]
betehess: I think one should perhaps make the readers implicit per language - perhaps that would allow one to select async readers more easily...
13:48:56 [betehess]
hey bblfish
13:49:00 [bblfish]
hi
13:49:03 [betehess]
(/me is in a meeting)
13:49:06 [betehess]
but I can comment
13:49:23 [betehess]
timbl() is just a method on LD
13:49:39 [betehess]
it's the way to get the best of LD :-)
13:49:45 [betehess]
it's the way to get the best out of LD :-)
13:49:45 [bblfish]
ah yes :-)
13:49:51 [betehess]
the "out" is important
13:50:00 [bblfish]
time before load?
13:50:04 [betehess]
when you leave LD, you enter the real world
13:50:21 [betehess]
actually, LD starts doing things as soon as it knows about them
13:50:34 [betehess]
see the underlying future in the implementation
13:50:57 [bblfish]
ok, yes. I'll use it for WebID - which does not require me to follow things
13:50:59 [betehess]
but when you want explicitly go out of the monad (yes it's one), you need to wait for answers
13:51:12 [bblfish]
but does require me to be able to read a number of mime types
13:51:24 [betehess]
I focused on the hard part for the moment
13:51:34 [betehess]
I'll add datatype projections tonight
13:51:49 [betehess]
also, I want one to say that he wants not more that X results
13:51:51 [bblfish]
ah ok. Good perhaps I'll leave you to do that, before I do it wrong
13:52:01 [betehess]
I also need to come up with a way to express errors
13:52:14 [betehess]
yeah, this one is easy
13:52:26 [betehess]
I've tried so many different approached to define this API
13:52:37 [betehess]
but I really like this one now
13:52:43 [bblfish]
ah good.
13:52:59 [betehess]
have you seen the "type LD[A] <: LDInterface[A]" trick?
13:53:03 [betehess]
very neat
13:53:24 [betehess]
because they depend to other
13:53:33 [bblfish]
I was reading it
13:53:35 [betehess]
and you define them together
13:53:50 [betehess]
eg. [[ def map[A](f: S ⇒ A): LD[A] ]]
13:53:58 [bblfish]
this one is a bit difficult to follow
13:54:03 [bblfish]
def followAll(predicate: IRI)(implicit ev: S =:= Iterable[IRI]): LD[Iterable[Node]] = {
13:54:03 [bblfish]
val f = future map ev flatMap { iris ⇒
13:54:16 [betehess]
ok, you're already in the implementation
13:54:19 [amy]
amy (~amy@30-6-207.wireless.csail.mit.edu) has joined #dig
13:54:23 [betehess]
let me find the doc for you
13:54:41 [betehess]
http://www.scala-lang.org/api/current/index.html#scala.Predef$$$eq$colon$eq
13:54:54 [bblfish]
yes, I asked on the scala mailing list
13:55:03 [betehess]
=:= operates at the type-level
13:55:15 [bblfish]
Is that saying that either followAll or follow can be used, depending on the type of S?
13:55:16 [betehess]
and gives you the evidence that the type constraint is ok
13:55:20 [betehess]
yes
13:55:39 [betehess]
Scala will not let you call followAll on a LD[String] for example
13:55:48 [betehess]
only on LD[Iterable[IRI]]
13:56:10 [betehess]
could be made more flexible with any subtype of Iterable, but good enough for the moment
13:56:16 [bblfish]
but I could not find where ev was implicity defined for "future map ev"
13:56:23 [bblfish]
in followAll;
13:56:44 [betehess]
look at the implicit
13:56:53 [betehess]
"implicit ev"
13:56:54 [bblfish]
"Scala will not let you call followAll on a LD[String] for example" -> interesting
13:56:56 [betehess]
that's the ev
13:57:11 [bblfish]
yes, but where is that implicit object defined?
13:57:14 [betehess]
it's an instance of =:=
13:57:23 [betehess]
in Predef
13:57:31 [betehess]
I just gave you the link to the doc
13:57:39 [bblfish]
ah.
13:57:55 [betehess]
you always have a hidden "import scala.Predef._"
13:58:02 [betehess]
it's worth looking at it
13:58:14 [bblfish]
I was looking for a function to transform a Iterator[Sting] into a Iterator[IRI] or somehting
13:58:21 [betehess]
and see what kind of implicits and goodness scala gives you by default
13:58:51 [betehess]
in this case, the evidence tell you that they are the same
13:59:05 [bblfish]
ah ok
13:59:07 [betehess]
so you can just call ev.apply()
13:59:08 [bblfish]
thanks
13:59:15 [betehess]
and you have the "conversion"
14:00:03 [betehess]
in Java, you would have had to return a special class where the special would be made available
14:00:10 [betehess]
it's just cumbersome
14:00:21 [bblfish]
ok. I should be able to follow up from there.
14:00:29 [betehess]
here, you have a much more dynamic-language style
14:00:33 [betehess]
but type-safe
14:00:44 [betehess]
take take Python/JavaScript/Ruby :-)
14:00:53 [betehess]
s/take take/take that/
14:01:05 [bblfish]
I was thinking of continuing in Play 2.0 for the WWW2012 because I won't have time to hack a TLS layer once more. And play has some buzz, so perhaps that could be useful.
14:01:13 [betehess]
yep
14:01:33 [betehess]
all you'll do in play will be easy to port to blueeyes
14:01:54 [bblfish]
ah good. I was about to use their iteratees, but perhaps your LD is better
14:02:03 [bblfish]
which is why I was reading your code
14:02:24 [betehess]
iteratees for what exactly?
14:02:43 [betehess]
I mean, I believe we're good if we wrap the parsing in a Future
14:02:58 [betehess]
and we let the web server taking care of the asynchrnous part
14:03:05 [betehess]
(or not :-)
14:03:31 [betehess]
the only thing it means is that we have to wait for the end of the stream before firing the parser
14:03:33 [bblfish]
https://gist.github.com/17a14b5c7c643a6b481b
14:03:36 [betehess]
but I believe it's fine
14:03:40 [betehess]
at least for now
14:03:51 [betehess]
because we need the entire graph all at once anyway
14:04:26 [betehess]
nice
14:05:03 [bblfish]
well one could have a streaming SPARQL
14:05:38 [bblfish]
but yes. there is also the need for a strreaming result
14:05:52 [bblfish]
like when you just want to write a proxy
14:06:09 [bblfish]
for rdflib.js to get around CORS
14:06:15 [bblfish]
but perhaps linked data is not needed there
14:07:03 [bblfish]
thanks
14:08:49 [bblfish]
I'll move to the LD library for now and forget iteratees
14:09:00 [bblfish]
then it will be more portable
15:00:40 [cheater_]
cheater_ has quit (Ping timeout: 252 seconds)
16:04:36 [scor]
scor (~scor@drupal.org/user/52142/view) has joined #dig
16:04:36 [scor]
scor has quit (Excess Flood)
16:04:58 [scor]
scor (~scor@drupal.org/user/52142/view) has joined #dig
16:46:56 [scor]
scor has quit (Read error: Connection reset by peer)
16:47:11 [scor]
scor (~scor@drupal.org/user/52142/view) has joined #dig
16:47:29 [scor]
scor has quit (Client Quit)
17:04:32 [cheater]
cheater (~cheater@p57AEB459.dip.t-dialin.net) has joined #dig
17:29:33 [bblfish]
betehess: the problem with those Readers is that it uses up one thread -> https://github.com/betehess/pimp-my-rdf/blob/master/linked-data/src/main/scala/LinkedDataMemoryKB.scala#L59
17:31:43 [bblfish]
that is what the code I was writing with Iteratees is trying to avoid https://gist.github.com/17a14b5c7c643a6b481b#L122
17:47:29 [bblfish]
what we need really is the equivalent of the RDFReader[Rdf <: RDF, Serialization <: RDFSerialization] but for async reading.
17:47:43 [bblfish]
AsynRDFReader...
17:54:23 [bblfish]
ah yes, and presently we would need a way to be able to prefer async readers when necessary but fallback to blocking ones when none are available (eg: rdfa ( or turtle if cpu efficiency is important))
19:16:37 [cheater]
cheater has quit (Ping timeout: 248 seconds)
19:17:51 [cheater]
cheater (~cheater@p5089749D.dip.t-dialin.net) has joined #dig
19:37:00 [betehess]
bblfish, it's ok as it's only an implementation detail. in practice, I'm gonna use the http client from BlueEyes, which is using akka/netty
19:38:20 [bblfish]
is that client seperate?
19:38:28 [bblfish]
I mean a seperate library?
19:39:33 [bblfish]
yes, but you still need to avoid using the Reader or those blockin IO things...
19:40:17 [bblfish]
IT is true that the Play 2.0 library does not feel industrial strenght. It's a play library i suppose...
19:40:35 [bblfish]
and now for something completely different http://www.youtube.com/watch?v=NLy4cvRx7Vc
19:41:33 [bblfish]
this came up doing a philoweb discussion with Blaine Cook in Paris, when Harry Halping remarked that the web is linking up the unconscious
19:44:53 [Pipian_]
Pipian_ (~pipian@31-34-204.wireless.csail.mit.edu) has joined #dig
20:24:03 [cheater]
cheater has quit (Ping timeout: 265 seconds)
21:04:48 [cheater]
cheater (~cheater@p57AEBAB8.dip.t-dialin.net) has joined #dig
21:38:07 [tlr]
tlr (~tlr@80.187.201.77) has joined #dig
21:54:30 [tlr]
tlr has quit (Quit: tlr)
21:54:57 [tlr]
tlr (~tlr@80.187.201.77) has joined #dig
22:17:11 [Pipian_]
Pipian_ has quit (Quit: Pipian_)
22:41:33 [tlr]
tlr has quit (Quit: tlr)
23:59:57 [melvster]
melvster has quit (Ping timeout: 244 seconds)