I did a third Synth, this time I got it 100% synthy. In this try, I used about 30 images of Karlsruhe, I did during a night session. I also used a panorama, I created out of a few of this images. This seems to be a quite good approach to help Photosynth to create the good Synth.
I’ve also used the first time the map feature you can find at your Synth’s page.
You simply select the place, where your Synth belongs to and save it along with it.
If you are interested, go to Manning Publications Co. and get an (almost) free White (green) paper about IronRuby. It will cost you only your e-Mail address and clicking the opt-out link as soon as you received the first newsletter.
“IronRuby is an implementation of the Ruby language on the .NET Framework. That means when it’s complete it will have the same language features as Matz’s Ruby Implementation (MRI) 1.8.6 but backed up by the intrinsic power that the .NET Framework harnesses.”
Dana Coffey created a list of 25 tools you might also helpful. Nice list, though.
“With traveling and use of many different computers, many geeks (and geek girls) often find a need to have a uniform set of tools handy wherever we may be. I’ve put together a list of 25 invaluable portable apps that can be installed on an Ipod or Thumb Drive. These are really cool!”
Since Photosynth was announced the very first time, I was keen to try out this technology. Finally, Photosynth became public and you can create your own synths.
After installing the Browser plug-in you select “Create your Synth” on the Photosynth Web site.
To sign in you’ll need a Windows Live account – probably you have a messenger account. You’ll start a synth by selecting a set of photos.
The dialog is quite self-evident. Don’t forget to select the license you want to use for the synth. That’s quite important as each and every synth is public available.
Select “Synth” and then just wait…
You’ll probably get a good “synthy” rate.
And that’s what you finally get:
Source: http://www.photosynth.net/
If you are not sure if a DGS instance provides a certain extension, just have a look at the metadata of the service, e.g. http://www.restful.ws/datagridservice/meta. You will find the all the available extensions with the predicate http://www.webcomposition.net/2008″02/dgs/meta/extension (we say “has extension”). In the example below we find the SA-REST extension I have introduced yesterday.
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:ns="http://purl.org/dc/elements/1.1/"
xmlns:crud="http://www.webcomposition.net/2008/02/dgs/crud#"
xmlns:meta="http://www.webcomposition.net/2008/02/dgs/meta/"
xmlns:sarest="http://lsdis.cs.uga.edu/SAREST#">
<rdf:Description rdf:about="http://www.restful.ws/DataGridService">
<!-- ... -->
<meta:extension>WebComposition.Dgs.Extensions.SaRest.SaRestHandler</meta:extension>
<!-- ... -->
</rdf:Description>
<rdf:RDF>
The last few evenings I spend writing an extension concept for the WebComposition/DGS approach. Initially, I was looking for a semantic description for the RESTful interface of the DGS. There are plenty approaches and a lot of research is going on for extending the WSDL interfaces with semantics. OWL-S and WSMO might be the most important examples within this field. However, it appears to be a bit more tricky for REST-driven approaches. For the DGS, I decided to try the SA-REST approach of the Kno.e.sis Services Science Lab of the Wright State University, Ohio.
<rdf:Description rdf:about="http://localhost/datagridservice/DataGridService">
<SAREST:input rdf:resource="http://lsdis.cs.uga.edu/ont.owl#Location_Query" />
<SAREST:output rdf:resource="http://lsdis.cs.uga.edu/ont.owl#Location" />
<SAREST:action>HTTP GET</SAREST:action>
<SAREST:lifting rdf:resource="http://www.restful.ws/lifting.xsl" />
<SAREST:lowering rdf:resource="http://www.restful.ws/lowering.xsl" />
<SAREST:operation rdf:resource="http://lsdis.cs.uga.edu/ont.owl#Location_Search" />
</rdf:Description>
However, I did not want to make this as a internal component of the DGS as is a research project, and no recommendation or standard is out there yet. So I came along with the extension concept of the DGS that allows dynamically loading of additional extensions in addition to the core components of the DGS.
The IExtension interface provides hotspots were own code can be executed right before and after one of the CRUD (Create, Read, Update, Delete) events.
namespace WebComposition.Dgs.Extension
{
public interface IExtension
{
bool CreateStartUp(ref ExecutionContext context);
bool CreateTearDown(ref ExecutionContext context);
bool ReadStartUp(ref ExecutionContext context);
//...
}
}
The ExecutionContext contains the request URI, the corresponding data adapter and (if already available) the current content to be returned with the response.
The extension can modify or create the content to be returned. In this case the return value must be set to false. Returning this dirty flag the DGS knows that the extension provided a new content to be returned. Any further internal functionality by the DGS is thus skipped and the newly provided content from the extension is returned.
To keep the WebComposition/DGS approach as flexible as possible, extensions can be deployed at runtime. The DGS is instructed to use extension by specifying them within the web.config file.
<webComposition>
<dataGridService>
<extensions>
<extension type="WebComposition.Dgs.Extensions.SaRest.SaRestHandler,
WebComposition.Dgs.Extensions.SaRest,
Version=1.0.0.0,
Culture=neutral,
PublicKeyToken=null" />
</extensions>
...
</dataGridService>
</webComposition>
Based in this extension mechanism I created my very first extension to provide SA-REST support. If you have a closer look to SA-REST you might realize a drawback of the approach (one that is directly related to the REST principles). When using RDFa or any other microformat in HTML/XHTML the description of the service is rather static. The DGS on the other hand provides a highly flexible solution. Here, the full power of the DGS turn up. Analyzing the SA-REST annotation you will realize that you have RDF triples, e.g. metadata. This metadata can be stored within the DGS of course.
If we have a closer look on this metadata we can add this metadata by performing an updated on your service’s meta URI. In my case it is http://localhost/datagridservice/DataGridService/meta. Below we use some RDF based on the originally SA-REST example.
The SA-REST extension now extends the URI scope of the DGS – which is actually a very cool feature. Once deployed, the /meta scope is extended with /meta/sarest. If you now perform a GET request to http://localhost/datagridservice/DataGridService/meta/sarest. The extension will return the corresponding SA-REST metadata we used above.
To round up this exercise I’ve also created a set of XSL transformations that create XHTML to be used within any Web page. E.g. the SA-REST annotation mixed with the content, again based on the original SA-REST example, would look like below. Keep in mind, the XHTML snippet you see here was dynamically created by the DGS itself using a transformation.
<p about="http://localhost/datagridservice/DataGridService" xmlns="http://www.w3.org/1999/xhtml" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:sarest="http://lsdis.cs.uga.edu/SAREST#">
The logical input of this service is an
<span property="sarest:input">http://lsdis.cs.uga.edu/ont.owl#Location_Query</span>
object. The logical output of this service is a list of
<span property="sarest:output">http://lsdis.cs.uga.edu/ont.owl#Location</span>
objects. This service should be invoked using an
<span property="sarest:action">HTTP GET</span>
request.
<meta property="sarest:lifting" content="http://www.restful.ws/lifting.xsl" />
<meta property="sarest:lowering" content="http://www.restful.ws/lowering.xsl" />
<meta property="sarest:operation" content="http://lsdis.cs.uga.edu/ont.owl#Location_Search" />
</p>
The extension concept allows to add new custom components and to customize the DGS even more while the SA-REST extension provides a very first capability to describe the DGS’ RESTful interface in a semantic way.
I am going to do a second proof of concept using another approach describing RESTful services soon to show the flexibility of the extension concept.
Amer Gerzic created a great plug-in to format source code while writing a post in Windows Live Writer.
You simply paste the code into the plug-in Window, specify the appearance of the code snippet.
He supports a wide range of languages within this plug-in which makes it so interesting. Currently supported languages are ASPX, C, C#, C++, COBOL, Cold Fusion, CSS, Eiffel, Fortran, Haskell, Java, JavaScript, JScript, Mercury, MSIL, Pascal, Perl, PHP, Python, Ruby, SQL, Visual Basic, Visual Basic Script, XML.
Jon DeVaan and Steven Sinofsky, both senior managers for the upcoming Windows 7, are hosting a blog called Engineering Windows 7, inviting everybody to comment about the future development of the new Windows platform. Actually, they only request to follow a few guidelines that however should be self-evident following a certain netiquette.
“We’re excited about this blog. As active bloggers on Microsoft’s intranet we are both looking forward to turning our attention and blogging energies towards the community outside Microsoft. We know the ins and outs of blogging and expect to have fun, provide great information, and also make a few mistakes. We know we’ll misspeak or what we say will be heard differently than we intended. We’re not worried. All we ask is that we have a dialog based on mutual respect and the shared goal of making a great release of Windows 7.”
Today, I spent some minutes to perform an experiment on linked data. The D2R server at L3S – University of Hannover publishes a weekly update version of the DBLP bibliography. The URIs from the Hannover server can thus be used to to set RDF links to DBLP data.
The FOAF profile is quite meaningless when used in a stand-alone to the machine-readable Web, similar to HTML pages without any links. With additional links to other machine-readable Web – and there are quite a lot resources available right now on the Web but you still have to find them. I was told a very visual metaphor where you could understand the Semantic Web as it is today as a country with hundreds or thousands of train stations but no tracks between those stations. As long as there are no tracks build, the train stations do not provide any added value. Similar it is to the Semantic Web. Unfortunately, establishing the links between the resources is still a very manual and time intensive job that must be accomplished by the human user.
Once linked, it becomes interesting when using the appropriate tools to browse these information. The best (even when experimental) tools therefore are the following Semantic Browsers:
To link myself to the DBLP database URI, I simply have to add an owl:sameAs tag to my FOAF profile. This allows to follow Semantic Web Browsers the links to the DBLP database. The different kinds of links you can add to your profile can are explained in a tutorial at FU Berlin.
As adding these links is still a manual process, I now think of creating a small component that will update publications in my FOAF file in the future based on a XML input file. That will allow me to semi-automate the process of updating the FOAF file. Some good reasons are
Comments are warmly welcomed.
Simple but powerful: http://live.sysinternals.com.
What they say:
“This is a file share allowing access to all Sysinternals utilities. We have developed this to test an alternate distribution mechanism for our utilities. This will allow you to run these tools from any computer connected to the Internet without having to navigate to a webpage, download and extract the zip file.”
What you get:
