stefan.goessner

JSONPath - XPath for JSON

2007-09-01T23:14:00.000+02:00

Here and there on the web we can find a discussion or solution for something like XPath for JSON. Despite the fact, that JSON structures can be processed by the C family of programming languages quite easily, there should be a benefit in having some kind of XPath4JSON.

So I was thinking about a suitable path expression syntax for addressing portions of any JSON structure. Those path expressions should

be naturally based on C language family characteristics.
cover only essential parts of XPath 1.0.

As a result here is JSONPath, wich is a dual thing. Primarily JSONPath is a path expression syntax, which can select parts of JSON structures in the same way as XPath expressions select nodes of XML documents. Such an expression may look like

$..book[2].title

and is quite similar to its XPath counterpart

//book[3]/title

Currently there is a small set of nine JSONPath syntax elements, which allows the construction of sophisticated path expressions.

Furthermore JSONPath is a lightweight tool implemented in Javascript and PHP for accessing JSON structures on the client and the server.

You can download

for free and read more about it.

Update:

Atif Aziz came up with a C# port of JSONPath in a very short time (jsonpath.cs). Thanks for that.

JSON XPath Javascript PHP C#

Converting Between XML and JSON @ XML.com

2006-06-02T13:27:00.000+02:00

xml.com has published my article Converting Between XML and JSON.

The conversion scripts are here.

Update:

There are some bug fixes and updates available to xml2json.js and json2xml.js. Read more in the download section.

XML JSON

Towel Day

2006-05-25T12:59:00.000+02:00

Don't forget … today is towel day.

The reason why this date was chosen, is obviously a numerical one:

25₁₆ + 5₁₆ = 42₁₀

TowelDay

XTech 2006

2006-05-24T16:25:00.000+02:00

I had the opportunity to attend the web technology conference XTech 2006 in Amsterdam last week.

All in all it was a great conference, starting with an Ajax Developers' Day chaired by Simon Willison of Yahoo!.

What followed were 3 days of interesting sessions and conversation with nice people mostly about technical stuff.

Finally the real highlight was the closing note "Javascript 2 and the Future of the Web" of Brendan Eich, the inventor of javascript.

XTech2006

Web Component Model

2006-04-07T13:12:00.000+02:00

After reading the article about ALE - Ajax Linking & Embedding over at Ajaxian I was thinking a while about the potential of this concept. I wasn't so much drawing the parallel to OLE, but stepped down a level to the concept of Microsoft's COM-Programming.

Basically COM-Interfaces allow design by contract via immutable interfaces and demand separation of interface and implementation. Given this, COM-components implementing identical interfaces are arbitrarily interchangeable.

Considering an inline web component, we might start with a clearly defined document fragment. A very good example for that is the open standard microformat XOXO, which is

A simple, open outline format written in standard XHTML and suitable for embedding in (X)HTML, Atom, RSS, and arbitrary XML.

Given a specific XOXO structure, we could easily define two different presentations via CSS, which might be even switched by the user.

But what's about behaviour. XOXO components might be

collapsable/expandable (example),
resortable via drag and drop (example by Tim Taylor).
collapsable/expandable and editable (example by Les Orchard).

So if there would be a standardized object interface – perhaps defined alongside with the microformats specification, we rather did a big step forward to a truely reusable, implementation independent inline web component. The interface definition of a collapsable XOXO element might look somewhat like:

interface XOXOCollapsableElement: Element {
void collapseItem(bool collapse);
void forEachItem(Function callback);
NodeList filterItems(Function callback);
...
};

There might be another interface for an editable XOXO element.

interface XOXoEditableElement: Element {
...
};

Now as a user i could download a specific XOXO object implementation, which implements either both interfaces or merely the XOXOCollapsableElement interface.

I believe, the long term benefit is worth the effort of agreeing to common interfaces for heavily reused inline web components.

Ajax DOM Microformats Javascript

Das wissenschaftliche Web

2006-03-02T18:40:00.000+01:00

Der CSS Krieger George Chavchanidze kritisiert die gegenwärtigen Webstandards aus der Sicht eines Wissenschaftlers …

Being emerged in European Centre for Nuclear Research (CERN), world wide web quickly evolved into entertainment oriented media and left many scientists disappointed. Web standards were science unfriendly and embedding complex mathematical formulae in web pages was far from being easy.

… und spricht mir damit aus der Seele. Es zeichnet sich speziell bei der Darstellung mathematischer Formeln keine allgemeine Einigung auf einen gemeinsamen Markup Standard ab; nicht zuletzt wegen individueller Vorlieben.

Some dislike angle brackets some curly ones, some want to have self contained markup, some want to integrate math oriented markup with the rest of webstandards, some want to code pages manually, some think that what they see is what they get, some prefer to have clear hierarchical structure, some vote for drastically abridged Unicode based notations

Trotz dieser gegenwärtig "verrückten" Verhältnisse sieht er einen natürlichen Ausweg einhergehend mit der Weiterentwicklung – und Implementierung – von CSS (inline-blocks, inline-tables,…) und der Unterstützung mathematischer Unicode-Bereiche. Hierbei haben offensichtlich die Browser Opera und Safari die Nase vorn.

Flankiert wird dieser Trend aus seiner Sicht durch clientseitige Webanwendungen zur Erstellung/Darstellung mathematischer Formeln. Ich freue mich, dass er in diesem Zusammenhang neben jsMat, AsciiMathML und HMath auch Wiky erwähnt.

Math CSS

Math Is Easy ...

2006-03-02T17:44:00.000+01:00

from: Phantomakos
via: technorati

WikyBloggerBox

2006-02-25T16:49:00.000+01:00

As a proof of concept to combine Blogger with a pure clientside Wiki/HTML converter, I implemented WikyBloggerBox. In fact it is the modified BloggerBox and WikyBox, which works on top of Blogger's Atom API for remote communication and Wiky.

Some noteworthy points are:

conversion from/to Wiki syntax to/from HTML is performed clientside. So Blogger only sees validating XHTML.
The HTML code create depends only minimally on internal CSS – as long as no math formulas are used. So this solution is supposed to be friendly to weblog readers.
Wiky supports a simplified LaTeX markup to create cross-browser math formulas purely in HTML/CSS.

Blogger Wiki Math

Wiky: A Clientside Wiki/Html Converter

2006-02-21T16:54:00.000+01:00

Wiky is a bidirectional Wiki markup to HTML converter written in javascript. So there is no need for the web server to convert or even store wiki text, just plain HTML — yes, I like smart clients. Besides converting wiki markup, Wiky also can do syntax highlighting and translate LaTeX style math formulas to HTML+CSS.

In fact Wiky + inplace editing is the way I am adding content to my web pages.

[ read more ...]

Wiki Math Javascript

JSONT - Transforming JSON

2006-02-03T22:05:00.000+01:00

In XML we can transform documents by another XML document containing transformation rules (XSLT) and applying these rules using an XSLT-processor.

Adopting that concept I have been experimenting with a set of transformation rules written in JSON.

Now in analogy to XML/XSLT the combination JSON/JSONT can be used to transform JSON data into any other format by applying a specific set of rules.

Die Geschichte der Familie der "C"-Sprachen ...

2006-02-02T13:30:00.000+01:00

... ist vergnüglich zu lesen.

Programming

Remote Json

2006-01-26T20:09:00.000+01:00

I really like Json and use it as a data exchange format between client and server for quite some time.

Yahoo! and del.icio.us are prominent representatives that currently offer web services based upon Json.

In order to use these web services in your web page you unfortunately cannot use standard Ajax without a proxy script on your web server.

As a way out of this we can adopt the dynamic <script> element approach. In his well written article Jason Levitt illustrates, how to access Json data from remote web servers.

Despite the benefit of this solution using a <script> element – either static or dynamic, one problem remains depending on the way, the remote server is wrapping the Json data:

{"a":"b"}
There is no way to deal with anonymous data recieved by the <script> element.
var x={"a":"b"}
Here the data is accessible through variable x, which is visible in the client's global scope. However the exact time of the data availability is not known, as it is delivered by an asynchron process.
f({"a":"b"});
This is the best way, as the function f will get called automatically, when the data is available. But how do remote web service and web client agree upon the function name?
1. The web service rigidly dictates the name of the callback function.
2. The web client sends the callback name as part of its request.

I wrote a javascript function remoteJson that handles incoming Json data according to cases 2. + 3. from static as well as dynamic <script> elements.

That function remoteJson(listener) expects a single object as argument. The optional data members of this object are:

"uri":: The uri to get the Json data from, which is equivalent to the src-attribute of the dynamic <script> element. When omitted, a corresponding static <script> element is expected in the same document.
"callback":: A reference to the callback function with no arguments. When omitted, an automatic callback from the web service according to case 3. will occur.
"condition":: A boolean javascript expression as a string, which will be evaluated to decide, if the Json data has been completely loaded. Only needed in combination with callback.

An example call to del.icio.us with a static <script> element might be:

remoteJson({"callback": function(){alert(Delicious.posts.length);},
            "condition": "typeof(Delicious) != 'undefined'"});

with the corresponding <script> element somewhere on the same page. The alternative call creating a dynamic <script> element looks like so:

remoteJson({"uri": "http://del.icio.us/feeds/json/yourname/",
            "callback": function(){alert(Delicious.posts.length);},
            "condition": "typeof(Delicious) != 'undefined'"});

And making a call relying on the server calling back into a provided function might look like:

remoteJson({"uri": "http://del.icio.us/feeds/json/yourname?callback=f"});

Finally here is the implementation of remoteJson:

function remoteJson(listener) {
   if (listener && listener.uri) { // create dynamic script element. 
      script = document.getElementById("remotejson");
      if (script) // script element may exist from previous call, so ..
         script.parentNode.removeChild(script);  // .. delete it.
      script = document.createElement("script"); // new script element.
      script.setAttribute("type", "text/javascript");
      script.setAttribute("id", "remotejson");
      script.setAttribute("src", listener.uri);
      document.getElementsByTagName("head")[0].appendChild(script);
   }
   if (listener && listener.condition && listener.callback)
      var timer = setInterval(function(){
                                 if (eval(listener.condition)) {
                                     clearInterval(timer);
                                     listener.callback(listener.target);
                                 }
                              }, 500);
}

This function basically works by periodically testing the provided condition twice a second and when true, the callback function is invoked.

It's a pity, that current browsers don't support the onload event handler also for the <script> element as they do with the <body> and <img> elements. This would make the function presented here obsolete.

Javascript Json Delicious

jQuery

2006-01-22T14:29:00.000+01:00

Jon Resig comes out with jQuery, a new lightweight javascript library.

A specific feature of jQuery is the $ function, adopted from the prototype framework. In prototype the $ function is a simple wrapper around the heavily used DOM method document.getElementById, accepting multiple ID's as arguments.

Jon's implementation is more powerful, as it

accepts general CSS selectors and …
… a useful subset of XPath expressions as arguments.
uses lazy evaluation of the arguments by an internal object.
returns that internal query object to allow call chains.

Just to get the idea, the following example uses plain DOM to change the text color of all paragraph elements with class attribute of "remark" to green :

var p = document.getElementsByTagName("p");
for (var i=0; i<p.length; i++)
   if (p[i].getAttribute("class") == "remark")
      p[i].style.color = "green";

Using jQuery we can write now:

$("a").filter(".remark").css("color", "green");
// or ..
$("a[@class='remark']").css("color", "green");

I really like this concept, especially the use of the paradigma:

A function, that deals with a unique object and doesn't have a specific return value, should always return that object.

Javascript DOM

BloggerBox

2006-01-12T07:30:00.000+01:00

I would like to introduce a lightweight Ajaxian application to the public. It allows to read, edit and delete Blogger posts on top of the Blogger Atom API.

I named it Bloggerbox and created a Demo weblog at Blogger to let you try it out.

Here is Bloggerbox working with that Demo Weblog.

BloggerBox consists of only 3 files and doesn't use any other libraries.

file name	description	kilobytes
`bloggerbox.html`	Html Css Javascript Webapplication as shown above.	11.0
`blogger.php`	Proxy to the Blogger Atom Api.	7.8
`http.js`	Simple wrapper around the XmlHttpRequest object.	3.4

You can dowload those three files as a zip archive.

In order to use BloggerBox with your own weblog, you have to install the files on your webserver and modify the following two lines in blogger.php by filling in your personal blogger data.

$bid = "1234567"; // hardwire your blog id ..
function userpass() { return base64_encode("username:password"); }

Please note, that BloggerBox

uses the content type application/xhtml xml, so it accepts only valid XHTML markup.
mostly avoids using the DOM-API and relies on a couple of regular expressions as well as JSON-based data exchange.
cannot handle comments as long as he Atom Api lacks that functionality.
is freely available under the Creative Commons GNU LGPL License.

It should be easy to integrate any Wysiwyg-Editor with BloggerBox. I intend to combine it with WIKI-like input capabilities and Latex-like math expressions. More about this later.

PS: This post was created using BloggerBox.

Ajax Blogger Atom Json

A Slideous Show

2005-11-18T11:44:00.000+01:00

I was using Eric Meyer's simple slide show system S5 for over more than a year in some of my lectures and most of my talks. To have one document for the web, for presentation and for print is great.

Since I never seriously used those highly sophisticated presentation tools that come with nearly every office software package out there, I was perfectly happy with S5.

Then, several weeks ago, I stumpled over Dave Raggett's Html Slidy and after a short inspection I even liked it more.

After using Html Slidy for a while I tried to customise and extend it. In fact I wanted ?

manual instead of automatical font resizing.
capability to select content during presentation and using the mouse for single-click navigation.
automatical generation of a Table of Content inside of a specific slide.
one-click completion of incremental slides.
menu buttons in the statusbar.
easy configuration and customization of behaviour and statusbar.

Patching Html Slidy turned out to be a surprisingly hard task for me, so I finally decided to write yet another script for controlling a slide show.

To get a first impression of Slideous you may want to start this presentation.

Please note, that Slideous hasn't implemented those cool features ?

different backgrounds for individual slides (Html Slidy).
semivisible / highlighted incremental items (S5).

I have tested Slideous with

Mozilla Firefox 1.5
Internet Explorer 6.0
Opera 8.5

[ read more ...]

SlideShow Javascript

Das tägliche - "Was zum Teufel"

2005-11-09T23:01:00.000+01:00

Alex Papadimoulis stöbert weltweit im Quellcode irgendwelcher Software und fördert Erstaunliches zu Tage. Seine Webseite nennt er bezeichnenderweise The Daily WTF, wobei Wikipedia WTF mit "Was zum Teufel" übersetzt.

Das heutige Code-Schnipselchen ist aus meiner Sicht eines der Besten seit Längerem.

Einer der Kommentatoren mutmasst, ob dieser Programmierer wohl nach Codezeilen bezahlt wird.

Rational Trigonometry

2005-09-23T17:34:00.000+02:00

After more than 2000 years of silence there is a current lively discussion about trigonometry. Dr. Wildberger, an Associate Professor in mathematics in Sydney Australia (University of New South Wales) simply states, that

Generations of students have struggled with classical trigonometry because the framework is wrong,

The transcendental functions sin, cos, tan, etc. are complicated, inaccurate and computation expensive, Dr. Wildberger argues in his new book Divine Proportions: Rational Trigonometry to Universal Geometry. He goes into some details in its first chapter, which is available online.

Instead of using distance and angle as fundamental measurable quantities, Wildberger introduces quadrance and spread as first citizen quantities. Quadrance is the distance squared and spread proportional to the sine squared of the angle between two lines.

(1)Q = (x₂ − x₁)² + (y₂ − y₁)²

(2)s(l₁, l₂) = (a₁ b₂ − a₂ b₁)²(a21+ b21)(a22+ b22)
with points
p₁ = (x₁, y₁)

p₂ = (x₂, y₂)
and lines
a₁ x + b₁ y + c₁

a₂ x + b₂ y + c₂

I can see the benefits of rational math expressions here, especially for 2D computer graphics algorithms. But I can't — at least at the time of this writing — see the necessity to do completely without distance and angle.

Especially in mechanics — from an engineer's view — I really do need not so much an angle, but it's derivatives, angular velocity and acceleration. Oscillations also seem to be very hard to handle without angles and distances.

In my mechanics lecture I usually give a short introduction to vector math, where I derive similar formulas to (2) above. I published a short article about this.

Nevertheless I welcome such new ideas and would really like to read Dr. Wildberger's complete book.

Trigonometry

Free Opera

2005-09-23T13:11:00.000+02:00

Der Browser Opera ist ab seiner Vollversion 8.5 nun kostenlos und werbefrei. Gleichzeitig setzt sich der gleichnamige norwegische Browserhersteller das Ziel, die Nummer zwei auf dem Browsermarkt zu werden.

Ich frage mich, warum diese strategische Entscheidung nicht bereits vor der Markteinführung von Firefox 1.0 umgesetzt wurde.

(via heise)

Web

Bildungspolitik im Vergleich

2005-08-18T13:13:00.000+02:00

Einen Vergleich der beabsichtigten Bildungspolitik von CDU/CSU, SDP, FPD und der Linkspartei stellt N24 in einer Kurzübersicht zur Verf�gung.

(via Bildungsblog)

Education

DOM Event registered multiple times

2005-08-17T15:46:00.000+02:00

According to the W3C DOM an event must not be registered more than once on the same object.

Now there is an issue with crossbrowser events using the DOM and Microsoft event registration model, which I am describing in detail here.

As a workaround we can extend the IE event target by an event list in order to store the registered event types by itself.

function addListener(obj, type, listener, capture) {
   if (obj.addEventListener)   // W3C DOM registering ..
      obj.addEventListener(type, listener, capture);
   else if (obj.attachEvent) { // IE 5/6 registering ..

      if (!obj.eventListeners)
         obj.eventListeners = [];
      if (!obj.eventListeners[type]) {
         obj.eventListeners[type] = true;
         obj.attachEvent("on"+type, listener);
      }
   }
}
function removeListener(obj, type, listener, capture) {
   if (obj.removeEventListener) // W3C DOM unregistering ..

      obj.removeEventListener(type, listener, capture);
   else if (obj.detachEvent) {  // IE 5/6 unregistering ..
      if (obj.eventListeners && obj.eventListeners[type]) {
         obj.eventListeners[type] = false;
         obj.detachEvent("on"+type, listener);
      }
   }
}

Using this and avoiding anonymous functions as event handlers resolves this issue with IE 6.

Javascript dom HTML

Google Maps

2005-07-03T00:49:00.000+02:00

Google hat in einer etwas überraschenden Aktion die Google Maps Programmierschnittstelle freigegeben. Damit kann nun jedermann Kartographie auf seiner eigenen Webseite betreiben ― nunja, solange er sich auf die USA oder Grossbritannien beschränkt. Gegenwärtig ist halt nur jener Teil der Welt von Google erschlossen. Als nächstes soll übrigens Deutschland hinzukommen. Jedoch liefert Google jetzt schon den Rest der Welt als Satellitenbilder aus.

Als erstes ben�tigt man einen Google Account, den ich bereits als Inhaber eines Google Mail (ehemals GMail) Zugangs besitze. Wer von mir eine Google Mail Einladung m�chte, hinterl�sst hier einfach einen diesbezüglichen Kommentar. Mit diesem Zugang kann man sich nun zur Teilnahme an der Betaphase von Google Maps anmelden .

Die Dokumentation der Javascript Programmierschnittstelle ist sehr gut und ein schneller Einstieg dank der übersichtlichen Beispiele leicht möglich.

longitude: latitude:
zoom:

Der weisse Punkt genau in Bildmitte zeigt meine Hochschule . Leider bietet ein Zoom mittels der Navigationssymbole in der linken oberen Ecke keine Qualitätsverbesserung. Dies scheint momentan nur in einigen Regionen vernünftig zu funktionieren.

In den beiden unteren Feldern kann man Längen- und Breitengrad eines beliebigen Ortes eingeben. Wer möchte, versucht es mal mit:

Europa (9.36035, 47.636718)
Olympiastadion, M�nchen ( 11.546312, 48.173171)
Hafen, Hamburg ( 9.9324989, 53.52127075)
Bodensee ( 9.36035, 47.636718)
Eiffelturm, Paris ( 2.294177, 48.85834)

TravelGIS bietet einen Webservice mit dem sich Breiten- und Längengrade beliebiger Orte auf der Welt bestimmen lassen.

Der Code für die hier demonstrierte kleine Webanwendung ist recht übersichtlich (hier als vollständige Webseite).

<html xmlns="http://www.w3.org/1999/xhtml">
  <body>
    <div id="map" style="width: 500px; height: 400px"></div>
    <script src="http://maps.google.com/maps?file=api&v=1&key=XXXX" 
            type="text/javascript"></script>
    <script type="text/javascript">
      var map = new GMap(document.getElementById("map"));
      map.addControl(new GSmallMapControl());
      map.setMapType(_SATELLITE_TYPE);
      function show(lon,lat) {
        map.centerAndZoom(new GPoint(lon,lat), 4);
      }
      show(8.91149039031456,52.0154866242451);
    </script>
    longitude: <input id="lon" type="text" value=""/> 
    latitude: <input id="lat" type="text" value=""/>
    <input type="button" value="go" 
           onclick="show(document.getElementById('lon').value,
                        document.getElementById('lat').value);"/>
  </body>
</html>

Das key=XXXX Attribute muss hierbei jeweils mit dem individuellen Schlüssel des eigenen Google Maps Zugangs ersetzt werden.

Google Maps Javascript

Firefox Download Counter

2005-06-03T15:31:00.000+02:00

Firefox is without doubt a remarkable, innovative web browser.

The browsers actual download number is available on Spread Firefox as an RSS-Feed — a small XML-File, which is updated every minute.

I decided to implement a small web application on top of that service. Well in fact I needn't to, since the smart people at Infocraft already did it in an excellent manner . So I implemented a stripped down version, just to learn, how it is working. You can see it in action in the box titled Firefox growth in the left column. Please note, that it's a little boring and not as pleasent as the original. So just sit and look at it for a while in order to see the numbers changing every minute.

The web appliction consists of a javascript fragment and a php file ffcounter.php. The javascript code uses the XmlHttpRequest object to poll the actual download number from my server.

function getHttpRequest(uri, callback) {
  var http = false;

  if (!!window.XMLHttpRequest) { 
    try { http = new XMLHttpRequest(); } 
    catch (e) { http = false; } 
  }
  else if (!!window.ActiveXObject) { 
    try {http = new ActiveXObject("Msxml2.XMLHTTP"); } 
    catch (e) { 
      try { http = new ActiveXObject("Microsoft.XMLHTTP"); } 
      catch (e) { http = false; }
    }
  }

  if (http) {
    http.onreadystatechange = function() {
      if (http.readyState == 4 && 
        http.status == 200 && callback)
        callback(http.responseText);
    };
    http.open("GET", uri, true);
    http.send(null);
  }
}

var ff;
function count() {
  getHttpRequest("/bin/ffcounter.php", 
                 function(res) {
                   document.getElementById("ffc").innerHTML = ff ? ff : res; 
                   document.getElementById("ffi").innerHTML = ff ? res-ff : 0;
                   ff = res; 
                 });
  setTimeout("count()", 60000); // wait one minute after each refresh ..
}

if (window.addEventListener) window.addEventListener("load", count, false);
else if (window.attachEvent) window.attachEvent("onload", count);

The setTimeout method is responsible for polling the updated download number every minute from my server. I cannot obtain the RSS feed directly from its original location because of security restrictions of the XmlHttprequest object.

This is where the php file ffcounter.php comes to the rescue. It is nearly identical with that on Infocraft . Instead of transfering the complete XML file to the web client, I am using a little regular expression to extract the download number. Here is the modified code.

<?php 
$host = "www.spreadfirefox.com"; 
$path = "/download_counter.php?ff=1"; 
$fp = fsockopen($host, 80, $errno, $errstr, 30); 
if ($fp) { 
   $out  = "GET $path HTTP/1.1\r\n"; 
   $out .= "Host: $host\r\n"; 
   $out .= "Connection: Keep-Alive\r\n\r\n"; 
   fwrite($fp, $out); 
   while (!feof($fp)) { 
      $buffer .= fgets($fp, 128); 
   }
   fclose($fp); 
   header('Content-Type: text/plain');
   header('Expires: Fri, 01 Jun 2005 00:00:00 GMT'); 
   if (preg_match("/<description>([0-9,]+)<\/description>/", $buffer, $matches))
      print($matches[1]);
} 
else { 
   print("$errstr ($errno)\n"); 
} 
?>

Feel free to use these scripts for whatever, as it is noted at Infocraft , where — again — the credits should go. I tested it with Firefox and IE6.

Update: Feed url had changed and was corrected!

Update: Finally I removed the script from my sidebar.

Firefox Javascript Ajax

einstein@home

2005-04-29T22:55:00.000+02:00

Seit Mitte Februar stelle ich die überschüssige Rechenleistung meines PC — immerhin meist über 90% — den Gravitationswellenforschern zur Verfügung.

Gravitationswellen wurden 1916 von Albert Einstein im Rahmen seiner Allgemeinen Relativit�tstheorie beschrieben, jedoch bis heute nicht zweifelsfrei nachgewiesen. Dieser Nachweis soll nun mittels dreier Laserinterferometer geführt werden. Ein Kleines steht bei Hannover und zwei Grosse im amerikanischen Hanford und Livingston. Das Problem ist nun hierbei, dass diese Interferometer einen kontinuierlichen, enormen Datenstrom liefern, der zu 99.99% aus unerwüschtem Rauschen besteht. Die vermuteten relevanten Daten aus diesem Rauschen herauszufiltern setzt somit eine extrem hohe Rechenleistung voraus. Einen tieferen Einblick vermittelt Boinc und AstroNews .

Einstein@home basiert nun auf einem genialen, kosteng�nstigen Verfahren, wonach durch verteiltes Rechnen auf Millionen von spendenden Privat-PCs weltweit die geforderte Rechenarbeit summiert werden kann.

Eine Anmeldung des eigenen PC's ist einfach mittels create account bewerkstelligt. Die abgezapfte Rechenleistung hab' ich bislang zu keiner Zeit gespürt. Der entsprechende Prozess läuft ja auch mit niedrigster Priorität im Hintergrund. Neue Datenpakete werden gelegentlich via Internet zur Bearbeitung heruntergeladen und aktuelle Berechnungsergebnisse hochgeladen. Als nette Dreingabe erhalten wir einen interessanten, animierten Bildschirmschoner .

Adobe kauft Macromedia

2005-04-18T18:42:00.000+02:00

Diese Fusion ist aus Sicht der Vektorgrafik-Anwender und -Entwickler eine interessante Neuigkeit. Adobe ist maßgeblich an der Entwicklung des Vektorgrafikstandards SVG beteiligt und unterstützt dessen Verbreitung mittels des bekannten SVG-Viewer Plugins. Dagegen hat Macromedia bislang sein weit verbreitetes, proprietäres Flash-Format gesetzt.

Wie Adobe nun künftig mit diesen beiden konkurrierenden Technologien in eigenem Hause umgeht, wird zur Zeit heiss diskutiert. F�r eine voraussichtliche Treue zu SVG spricht die j�ngste Kooperationsvereinbarung zwischen Adobe und dem Browserhersteller Opera. Letzterer ist ja erstaunlich weit in der Entwicklung seiner integrierten SVG-Fähigkeiten fortgeschritten.

Vermutungen gehen in die Richtung, dass dieses Zusammengehen eine Kräftebündelung gegen das Grafik-Subsystem Avalon darstellt. In jedem Fall sind die Karten ab heute neu gemischt.

Der transparente Surfer

2005-04-12T10:33:00.000+02:00

Weit über das Ziel hinaus schiesst offensichtlich Harald Lemke, Staatssekretär im hessischen Innenministerium, mit seiner Kritik an öffentlicher Förderung von Kryptographie und Anonymisierung im WWW.

Als Killerargumente führt er Kindesmissbrauch, organisierte Kriminalität und Terrorismus an. Die von der Politik favorisierte Einführung einer Vorratsdatenspeicherung im TK-Bereich geht Lemke dabei offensichtlich nicht weit genug. Er äussert nicht ganz unberechtigte Zweifel an deren technischer Durchführbarkeit.

Glücklicherweise gibt es sofort lauten Widerstand zur Sicherstellung des grundgesetzlich gesicherten Datenschutzes und Unterstützung des hier im Fokus stehenden Projekts.