Friday, July 28, 2006
Sean McGrathlinks to this post (0) comments
For decades now, well meaning theorists, architects and engineers have struggled with the problem of allowing electronic content to serve two needs : human readability and machine readability. For decades now, initiatives to create structured content vocabularies have come into existence, burned brightly in the full glare of enthusiasm+publicity only to then fade away into obscurity. I would guess that of all the SGML, XML vocabs I've come across over 20 years, 0.001% of them have actually made an impact. Now, you could argue that it is still "just a matter of time" until the tools improve to the point where the glorious future of semantic content creation/publication - as originally envisaged - can be ushered into the mainstream. Or, you could argue (as I do) that maybe - just maybe - there is something fundamentally wrong with the way we have been trying to enable the creation/publication of semantic content. Right now, people - ordinary people - are getting excited about microformats. For the first time *ever* ordinary folk are now motivated to start adding semantic information to their content. We SGML/XML folk should welcome it with open arms and help out where we can rather than look aghast at how microformats work. Semantic markup is happening at last. Surprise surprise, it is not taking the shape that we had anticipated. Thats life.
Ralf L¨ammel, Erik Meijerlinks to this post (0) comments
Initially, it may seem that one can set up a simple and faithful correspondence between XML types and object types. The first thing to notice is that such a correspondence certainly is not self-evident; there are dozens of X/O mapping technologies that assume quite different mapping rules. Let us try to define one such correspondence. We may start with the following associations between XSD types and C# types: – Global element declarations --- top-level classes.
– Global (complex) type definitions --- top-level classes.
– Element references --- setter/getter properties.
– Local element declarations --- setter/getter properties.
– Nested anonymous (complex) types --- nested classes. All such correspondences become debatable, convoluted, unsound or incomplete eventually. For instance, when mapping XML types to object types, the corresponding types typically suffer from ‘sloppiness’ in so far that static types fail to properly express certain validation constraints; the types typically suffer from ‘paradigm schizophrenia’: Who am I? A tree? A graph?. We use the term ‘X/O impedance mismatch’ to refer to all the conceptual and technical challenges that arise in a canonical X/O mapping context.
Thursday, July 27, 2006
Elias Torreslinks to this post (0) comments
- Queso AJAX Atom Browser: http://abdera.watson.ibm.com:8080/browser/
- Queso AJAX SPARQL UI: http://abdera.watson.ibm.com:8080/browser/sparql/
Mike Championlinks to this post (0) comments
You don't need to be scared about this functional construction and transformation stuff just because "introductory" articles on the subject start talking about Haskell, monads, lambda calculus, etc. in about the second paragraph. With the help of our friendly local ex-professors and Haskell geeks Dr. Meijer and Dr. Lämmel, I have learned to stop worrying and love monad comprehensions; we believe thatVB9 / C# 3.0 and the LINQ technologies will help bring functional programming to the masses, whether or not they know that they are doing it. The first step is to understand the power of language integrated QUERY for working with data and the functional construction approach to reshaping it rather than modifying it in place, even though C# 3.0 and XLinq still support traditional imperative data manipulation for all sorts of pragmatic reasons. The critical next step is to understand that mixing the two styles in the same section of code is like begging to be haunted by the Halloween Problem.
Monday, July 24, 2006
Phil Wainewrightlinks to this post (0) comments
If Web 2.0 really is a gold rush, this will be the first in history when the people pushing the maps are the ones who've had their fingers burned. Mapping mashups are the fool's gold of Web 2.0 not merely because they produce no revenue, but far more crucially because they add no new semantic value to the integrations they perform. The real wealth creators will be those who offer enterprise mashup prospectors some means of swiftly and manageably reconciling multiple different data structures when they bring separate information systems together.
Friday, July 14, 2006
Asynchronous WebService calls – the truth behind the Begin… End… functionslinks to this post (0) comments
I’ve finally solved this one – not that the resolution makes me happy, but it’s nice to finally explain the behavior. I ran into a funny behavior four years ago with WebService calls on the .Net platform. At that time, my idea was to launch webservice calls simultaneously against multiple backend webservices. The effect would be the pipelining of these requests.
. . .My answer to this problem four years ago was to place synchronous requests in a worker threadpool and manage the threads – it turns out that was the right call. After looking at the behavior of .Net, it appears that they are also running these calls on background threads. When doing this, you have to be conscientious in the number of threads being used to service these requests (especially if you’re making these from within a web application or webservice). I would have hoped the .Net implementation would have been more elegant than my thrown-together async threadpool, but it turns out that’s just not the case. Perhaps they could have used Overlapped IO with sockets available since winsock 2??? So, long and short… if you want to shotgun your webservice requests, make synchronous calls from worker threads and take the time to get that right.