www.ni-c.de » Development

Jetzt bereits Google Wave testen

ni.c — Sun, 26 Jul 2009 22:12:53 +0000

Ab dem 30. September wird Google 100.000 Beta-Invites für Google Wave verschicken, aber das ist noch ein paar Monate hin. Für diejenigen, die es gar nicht mehr erwarten können, gibt es jetzt PyGoWave (@PyGoWave). PyGoWave benutzt die Google Wave API in einer Open-Source Version.

Man sollte allerdings nicht zuviel erwarten, denn die aktuelle Version (alpha-0.2) ist nicht wirklich wie das echte Google Wave, das Interface von PyGoWave sieht noch vollkommen anders aus als die bereits bekannten Google Wave Screenshots. Auch die Funktionalität ist noch nicht vollkommen implementiert, allerdings können schon Wave Gadgets in einer Sandbox installiert, getestet und heruntergeladen werden.

Let’s be clear: PyGoWave is not the open-source version of Google Wave. It’s an early approximation of the open-source version, based on the Google Wave API. It’s still not completely usable and is riddled with bugs, but so is Google Wave itself. (via Mashable)

PyGoWave Server, PyGoWave Download bei Google Code

Bundestrojaner 2.0: Twitternder Keylogger

ni.c — Wed, 01 Jul 2009 20:59:26 +0000

Kyle McDonald hat einen Software Keylogger entwickelt, der die Tastenanschläge auf seinem Rechner in (fast) Echtzeit tweetet. Geschrieben hat er die Software in C++ und OpenFrameworks.

Der Keylogger postet alle 140 Tastenanschläge einen Tweet an Twitter. Um sich selbst zu schützen, hat er eine Whitelist mit privaten Wörtern wie Passwörter und Kreditkartennummern angelegt, die vor dem Posten an Twitter entfernt werden.

via hackaday.com

The Evolution of a Programmer

ni.c — Thu, 21 May 2009 00:24:58 +0000

High School/Jr.High

  10 PRINT "HELLO WORLD"
  20 END

First year in College

  program Hello(input, output)
    begin
      writeln('Hello World')
    end.

Senior year in College

  (defun hello
    (print
      (cons 'Hello (list 'World))))

New professional

  #include
  void main(void)
  {
    char *message[] = {"Hello ", "World"};
    int i;
 
    for(i = 0; i &lt; 2; ++i)
      printf("%s", message[i]);
    printf("\n");
  }

Seasoned professional

  #include 
  #include 
 
  class string
  {
  private:
    int size;
    char *ptr;
 
  string() : size(0), ptr(new char[1]) { ptr[0] = 0; }
 
    string(const string &s) : size(s.size)
    {
      ptr = new char[size + 1];
      strcpy(ptr, s.ptr);
    }
 
    ~string()
    {
      delete [] ptr;
    }
 
    friend ostream &operator <<(ostream &, const string &);
    string &operator=(const char *);
  };
 
  ostream &operator<<(ostream &stream, const string &s)
  {
    return(stream << s.ptr);
  }
 
  string &string::operator=(const char *chrs)
  {
    if (this != &chrs)
    {
      delete [] ptr;
     size = strlen(chrs);
      ptr = new char[size + 1];
      strcpy(ptr, chrs);
    }
    return(*this);
  }
 
  int main()
  {
    string str;
 
    str = "Hello World";
    cout << str << endl;
 
    return(0);
  }

Apprentice Hacker

  #!/usr/local/bin/perl
  $msg="Hello, world.\n";
  if ($#ARGV >;= 0) {
    while(defined($arg=shift(@ARGV))) {
      $outfilename = $arg;
      open(FILE, ">" . $outfilename) || die "Can't write $arg: $!\n";
      print (FILE $msg);
      close(FILE) || die "Can't close $arg: $!\n";
    }
  } else {
    print ($msg);
  }
  1;

Experienced Hacker

  #include
  #define S "Hello, World\n"
  main(){exit(printf(S) == strlen(S) ? 0 : 1);}

Seasoned Hacker

  % cc -o a.out ~/src/misc/hw/hw.c
  % a.out

Guru Hacker

  % echo "Hello, world."

New Manager

  10 PRINT "HELLO WORLD"
  20 END

Middle Manager

  mail -s "Hello, world." bob@b12
  Bob, could you please write me a program that prints "Hello, world."?
  I need it by tomorrow.
  ^D

Senior Manager

  % zmail jim
  I need a "Hello, world." program by this afternoon.

Chief Executive

  % letter
  letter: Command not found.
  % mail
  To: ^X ^F ^C
  % help mail
  help: Command not found.
  % damn!
  !: Event unrecognized
  % logout

Make your Blog Mobile Friendly

ni.c — Tue, 12 May 2009 22:08:17 +0000

Das mobile Internet ist nicht mehr aufzuhalten. Nicht erst seit der Einführung des Apple iPhones entdecken immer mehr Benutzer den Reiz, unterwegs mit dem Handy ins Internet zu gehen.
Doch leider sind viele der Webseiten noch nicht bereit für Besucher, die mit Handys oder anderen tragbaren Geräten auf die Seite zugreifen. [via]

Da ich selbst stolzer Besitzer eines Apple iPhones bin, strapaziert das Surfen mit EDGE meine Nerven doch ab und an. Damit das bei meinem Blog nicht der Fall ist, habe ich mich daran gemacht, diesen Blog für das iPhone und andere mobilen Geräte zu optimieren.

Da dieser Blog auf Wordpress basiert, habe ich mich nach Wordpress-Plugins umgesehen die meinen Vorstellungen entsprechen. Gefunden habe ich zwei Plugins, beide Plugins ermitteln die optimale Darstellung anhand des gesendeten User Agents und stellen somit immer die richtige Version zur Verfügung.

WPtouch

WPTouch optimiert das Blog für iPhone/iPod touch/Android. Testen kann man das Ergebnis der Optimierung mit dem iPhone oder auf dem Mac mit dem iPhone-Emulator iPhoney.

WP viewMobile

WP viewMobile optimiert den Blog für alle anderen mobilen Geräte. Das Ergebnis kann man mit dem Mobile-Emulator ready.mobi überprüfen. Dort bekommt man auch eine “mobile-score” für die getestete Seite.

Beide Plugins funktionieren parallel in der gleichen Wordpress-Installation fehlerfrei.

Google Web Toolkit & MD5

ni.c — Mon, 11 May 2009 22:19:17 +0000

Wer schon einmal versucht hat, im Google Web Toolkit (GWT) mit der Standard Java-Implementierung

MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
digest.update(...your data here...);
byte[] hash = digest.digest();

ein MD5-Hashing durchzuführen, wird folgendes Ergebnis erhalten haben:

...
[ERROR] Line ..: The import java.security cannot be resolved
[ERROR] Line ..: MessageDigest cannot be resolved to a type
[ERROR] Line ..: MessageDigest cannot be resolved
...

Das liegt daran, dass GWT das Paket java.security in der aktuellen Version nicht unterstützt. Dieses Problem kann man umgehen, indem man das MD5-Hashing mittels JavaScript durchführt:

function RotateLeft(lValue, iShiftBits) {
	return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits));
}
 
function AddUnsigned(lX,lY) {
	var lX4,lY4,lX8,lY8,lResult;
	lX8 = (lX & 0x80000000);
	lY8 = (lY & 0x80000000);
	lX4 = (lX & 0x40000000);
	lY4 = (lY & 0x40000000);
	lResult = (lX & 0x3FFFFFFF)+(lY & 0x3FFFFFFF);
	if (lX4 & lY4) {
		return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
	}
	if (lX4 | lY4) {
		if (lResult & 0x40000000) {
			return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
		} else {
			return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
		}
	} else {
		return (lResult ^ lX8 ^ lY8);
	}
}
 
function F(x,y,z) { return (x & y) | ((~x) & z); }
function G(x,y,z) { return (x & z) | (y & (~z)); }
function H(x,y,z) { return (x ^ y ^ z); }
function I(x,y,z) { return (y ^ (x | (~z))); }
 
function FF(a,b,c,d,x,s,ac) {
a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
return AddUnsigned(RotateLeft(a, s), b);
};
 
function GG(a,b,c,d,x,s,ac) {
	a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
	return AddUnsigned(RotateLeft(a, s), b);
};
 
function HH(a,b,c,d,x,s,ac) {
	a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
	return AddUnsigned(RotateLeft(a, s), b);
};
 
function II(a,b,c,d,x,s,ac) {
	a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
	return AddUnsigned(RotateLeft(a, s), b);
};
 
function ConvertToWordArray(string) {
	var lWordCount;
	var lMessageLength = string.length;
	var lNumberOfWords_temp1=lMessageLength + 8;
	var lNumberOfWords_temp2=(lNumberOfWords_temp1-(lNumberOfWords_temp1
	% 64))/64;
	var lNumberOfWords = (lNumberOfWords_temp2+1)*16;
	var lWordArray=Array(lNumberOfWords-1);
	var lBytePosition = 0;
	var lByteCount = 0;
	while ( lByteCount < lMessageLength ) {
		lWordCount = (lByteCount-(lByteCount % 4))/4;
		lBytePosition = (lByteCount % 4)*8;
		lWordArray[lWordCount] = (lWordArray[lWordCount] |
		(string.charCodeAt(lByteCount)<<lBytePosition));
		lByteCount++;
	}
	lWordCount = (lByteCount-(lByteCount % 4))/4;
	lBytePosition = (lByteCount % 4)*8;
	lWordArray[lWordCount] = lWordArray[lWordCount] |
	(0x80<<lBytePosition);
	lWordArray[lNumberOfWords-2] = lMessageLength<<3;
	lWordArray[lNumberOfWords-1] = lMessageLength>>>29;
	return lWordArray;
};
 
function WordToHex(lValue) {
	var WordToHexValue="",WordToHexValue_temp="",lByte,lCount;
	for (lCount = 0;lCount<=3;lCount++) {
		lByte = (lValue>>>(lCount*8)) & 255;
		WordToHexValue_temp = "0" + lByte.toString(16);
		WordToHexValue = WordToHexValue +
		WordToHexValue_temp.substr(WordToHexValue_temp.length-2,2);
	}
	return WordToHexValue;
};
 
function Utf8Encode(string) {
	string = string.replace(/\r\n/g,"\n");
	var utftext = "";
 
	for (var n = 0; n < string.length; n++) {
 
		var c = string.charCodeAt(n);
 
		if (c < 128) {
			utftext += String.fromCharCode(c);
		} else if((c > 127) && (c < 2048)) {
			utftext += String.fromCharCode((c >> 6) | 192);
			utftext += String.fromCharCode((c & 63) | 128);
		} else {
			utftext += String.fromCharCode((c >> 12) | 224);
			utftext += String.fromCharCode(((c >> 6) & 63) | 128);
			utftext += String.fromCharCode((c & 63) | 128);
		}
	}
 
	return utftext;
};
 
var x=Array();
var k,AA,BB,CC,DD,a,b,c,d;
var S11=7, S12=12, S13=17, S14=22;
var S21=5, S22=9 , S23=14, S24=20;
var S31=4, S32=11, S33=16, S34=23;
var S41=6, S42=10, S43=15, S44=21;
 
string = Utf8Encode(string);
 
x = ConvertToWordArray(string);
 
a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
 
for (k=0;k<x.length;k+=16) {
	AA=a; BB=b; CC=c; DD=d;
	a=FF(a,b,c,d,x[k+0], S11,0xD76AA478);
	d=FF(d,a,b,c,x[k+1], S12,0xE8C7B756);
	c=FF(c,d,a,b,x[k+2], S13,0x242070DB);
	b=FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE);
	a=FF(a,b,c,d,x[k+4], S11,0xF57C0FAF);
	d=FF(d,a,b,c,x[k+5], S12,0x4787C62A);
	c=FF(c,d,a,b,x[k+6], S13,0xA8304613);
	b=FF(b,c,d,a,x[k+7], S14,0xFD469501);
	a=FF(a,b,c,d,x[k+8], S11,0x698098D8);
	d=FF(d,a,b,c,x[k+9], S12,0x8B44F7AF);
	c=FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1);
	b=FF(b,c,d,a,x[k+11],S14,0x895CD7BE);
	a=FF(a,b,c,d,x[k+12],S11,0x6B901122);
	d=FF(d,a,b,c,x[k+13],S12,0xFD987193);
	c=FF(c,d,a,b,x[k+14],S13,0xA679438E);
	b=FF(b,c,d,a,x[k+15],S14,0x49B40821);
	a=GG(a,b,c,d,x[k+1], S21,0xF61E2562);
	d=GG(d,a,b,c,x[k+6], S22,0xC040B340);
	c=GG(c,d,a,b,x[k+11],S23,0x265E5A51);
	b=GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA);
	a=GG(a,b,c,d,x[k+5], S21,0xD62F105D);
	d=GG(d,a,b,c,x[k+10],S22,0x2441453);
	c=GG(c,d,a,b,x[k+15],S23,0xD8A1E681);
	b=GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8);
	a=GG(a,b,c,d,x[k+9], S21,0x21E1CDE6);
	d=GG(d,a,b,c,x[k+14],S22,0xC33707D6);
	c=GG(c,d,a,b,x[k+3], S23,0xF4D50D87);
	b=GG(b,c,d,a,x[k+8], S24,0x455A14ED);
	a=GG(a,b,c,d,x[k+13],S21,0xA9E3E905);
	d=GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8);
	c=GG(c,d,a,b,x[k+7], S23,0x676F02D9);
	b=GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A);
	a=HH(a,b,c,d,x[k+5], S31,0xFFFA3942);
	d=HH(d,a,b,c,x[k+8], S32,0x8771F681);
	c=HH(c,d,a,b,x[k+11],S33,0x6D9D6122);
	b=HH(b,c,d,a,x[k+14],S34,0xFDE5380C);
	a=HH(a,b,c,d,x[k+1], S31,0xA4BEEA44);
	d=HH(d,a,b,c,x[k+4], S32,0x4BDECFA9);
	c=HH(c,d,a,b,x[k+7], S33,0xF6BB4B60);
	b=HH(b,c,d,a,x[k+10],S34,0xBEBFBC70);
	a=HH(a,b,c,d,x[k+13],S31,0x289B7EC6);
	d=HH(d,a,b,c,x[k+0], S32,0xEAA127FA);
	c=HH(c,d,a,b,x[k+3], S33,0xD4EF3085);
	b=HH(b,c,d,a,x[k+6], S34,0x4881D05);
	a=HH(a,b,c,d,x[k+9], S31,0xD9D4D039);
	d=HH(d,a,b,c,x[k+12],S32,0xE6DB99E5);
	c=HH(c,d,a,b,x[k+15],S33,0x1FA27CF8);
	b=HH(b,c,d,a,x[k+2], S34,0xC4AC5665);
	a=II(a,b,c,d,x[k+0], S41,0xF4292244);
	d=II(d,a,b,c,x[k+7], S42,0x432AFF97);
	c=II(c,d,a,b,x[k+14],S43,0xAB9423A7);
	b=II(b,c,d,a,x[k+5], S44,0xFC93A039);
	a=II(a,b,c,d,x[k+12],S41,0x655B59C3);
	d=II(d,a,b,c,x[k+3], S42,0x8F0CCC92);
	c=II(c,d,a,b,x[k+10],S43,0xFFEFF47D);
	b=II(b,c,d,a,x[k+1], S44,0x85845DD1);
	a=II(a,b,c,d,x[k+8], S41,0x6FA87E4F);
	d=II(d,a,b,c,x[k+15],S42,0xFE2CE6E0);
	c=II(c,d,a,b,x[k+6], S43,0xA3014314);
	b=II(b,c,d,a,x[k+13],S44,0x4E0811A1);
	a=II(a,b,c,d,x[k+4], S41,0xF7537E82);
	d=II(d,a,b,c,x[k+11],S42,0xBD3AF235);
	c=II(c,d,a,b,x[k+2], S43,0x2AD7D2BB);
	b=II(b,c,d,a,x[k+9], S44,0xEB86D391);
	a=AddUnsigned(a,AA);
	b=AddUnsigned(b,BB);
	c=AddUnsigned(c,CC);
	d=AddUnsigned(d,DD);
}
 
var result = WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d);
 
return result.toLowerCase();

Diesen JavaScript-Code packt man nun in eine Java-Funktion:

public static native String convert(String string) /*-{
 
	// JavaScript-Code
 
	return result.toLowerCase();
}-*/;

Diese Funktion kann nun im normalen Java-Code von GWT aufgerufen werden, um den M5-Hash von z.Bsp. Passwörtern zu erzeugen.

download: Md5.java (6.84KB)
added: 12/05/2009
clicks: 266
description: A class to perform MD5 hashing in GWT with native JavaScript.

CeBIT: IBM erklärt Cloud Computing

ni.c — Mon, 02 Mar 2009 17:26:57 +0000

Eines der Top-Themen der diesjährigen CeBIT ist Cloud Computing. Diesen Trend hat auch der Aussteller IBM in Halle 2 (Stand A02) erkannt. Doch nur wenige wissen mit dem Begriff aus der Computertechnik etwas anzufangen – geschweige denn über die Funktionsweise. Diese Wissenslücke will IBM jetzt mit einem interessanten Modell schließen.

Wordpress Suchergebnisse verbessern

ni.c — Thu, 13 Nov 2008 16:34:00 +0000

Nach der Suchmaschinen optimierung dieses Blogs habe ich mich daran gemacht, die Suchergebniss-Seiten (Langing Sites) dieses Blogs zu optimieren. Aus diesem Grund habe ich nach geeigneten Wordpress-Plugins für diese Aufgabe gesucht und bin dabei auf die beiden folgenden Plugins gestoßen:

Search Hilite

The Search Hilite Plugin highlites Search-Words, from external Searches over Yahoo,Google, Lycos and Baidu, as well as WordPress internal Searches, on the Search Results-Pages.

Falls ein Blogpost von einer Suchmaschine aufgerufen wurde, highlightet dieses Plugin die Keywörter nach denen in der Suchmaschine gesucht wurde. So sieht der Besucher auf den ersten Blick an welcher Stelle auf seinen Suchbegriff eingegangen wird.

Landing Sites (de)

Wenn das Plugin in den Blog eingebaut ist, so werden Besucher, wenn er von einer Suchmaschine kommt, ähnlich relevante Artikel angeboten. Das ist sinnvoll, denn nun bekommt der Besucher sofort die nötigen Infos und verbleibt damit länger auf der Seite und wird vielleicht ein potenzieller Leser.

Falls ein Besucher durch einen Suchmaschineneintrag auf einem Blogpost landet, durchsucht dieses Plugin den kompletten Blog nach ähnlichen Blogposts, die zu den eingegeben Suchbegriffen passen. In diesem Blog werden dann die ähnlichen Posts anstelle der “Related Posts” auf der linken Seite angezeigt.

Leider funktionieren diese Plugins nicht zusammen mit dem Plugin WP Super Cache, welches die Seiten des Blogs cached um sie beim nächsten Zugriff auf die Seite schneller “servieren” zu können. Da die Blogposts aber unterschiedlich hervorgehobene Suchbegriffe haben können, kommt ein cachen der Seiten nicht mehr in Frage.

Zur Veranschaulichung der beiden Plugins kann man bei Google nach “Serializable Bufferedimage” suchen und dem Suchergebnis zu meinem Blog folgen. Auf dem aufgerufenen Blogpost sind dann die Begriffe Serializable und BufferedImage hervorgehoben und in der “About this entry”-Übersicht auf der linken Seite findet man den Eintrag: “Your search on www.google.de for Serializable BufferedImage:” mit zu den Suchbegriffen relevanten Blogposts.

Wordpress SEO: Meta-Tags

ni.c — Wed, 12 Nov 2008 19:18:16 +0000

Seit es Google gibt, ist die Bedeutung der Meta-Tags zweifellos in den Keller gesunken. Viele behaupten, Google interessiere sich gar nicht mehr für Meta-Tags. Damit wären Meta-Tags natürlich überflüssig. Bis heute gibt es aber auch die Meta-Tag-Fraktion, die an den Meta-Tags festhält und der festen Überzeugung ist, dass sich die richtige Wahl der Meta-Description und Meta-Keywords positiv auf das Ranking auswirkt.

Zunächst einmal ist die Behauptung “Google interessiert sich nicht mehr Meta-Tags” etwas pauschal ausgedrückt, denn natürlich gibt es auch heute noch den ein oder anderen Meta-Tag, der Einfluss auf den Googlebot hat. Auf der Google-Seite wird z.B. beschrieben, wie man den Googlebot an der Indexierung der eigenen Website hindern kann, und zwar per Meta-Tag:

oder

Im Prinzip ist das auch jedem der Meta-Tag-Gegner bekannt, wenn sie Meta-Tags pauschal ablehnen. Sie beziehen sich bei ihrer Kritik in erster Linie auf die Meta-Description und Meta-Keywords, danach folgen Meta-Angaben wie Author, Page-Topic, Revisit-After etc.

Google hat nun allerdings die Eigenschaft, bei manchen Suchergebnissen die Meta-Description anzuzeigen. Google zeigt die Meta-Description in den SERPs an, wenn man nach dem Domainnamen (oder einen Teil daraus) sucht bzw. wenn die Seite keinen Inhalt hat (z.B. bei vielen Frame- oder Flash-Seiten) oder wenn die gefundenen Suchbegriffe im Text so weit auseinander liegen, dass die Suchmaschine keinen sinnvollen Vorschautext anzeigen kann.

Deshalb habe ich meine Blogseiten um einige Meta-Daten erweitert. Ob es wirklich etwas bringt sei dahin gestellt, aber Schaden kann es nicht. Die folgenden Meta-Daten habe ich dazu in den Head-Bereich meiner Seite eingefügt:

Weitere SEO-Posts in diesem Blog:
Wordpress SEO: header.php Hack
Wordpress SEO: robots.txt

Wordpress SEO: header.php Hack

ni.c — Sun, 09 Nov 2008 14:36:53 +0000

Im Zuge der Suchmaschinenoptimierung dieses Blogs bin ich auf eine weitere leichte Möglichkeit der Optimierung gestoßen: Durch Meta-Angaben im Seitenkopf kann man beeinflussen, wie die Seite von Suchmaschinen behandelt wird.

Durch die Angabe “noopd” kann man zum Beispiel verhindern, dass der Titel und die Beschreibung für die Seite aus dem Open Directory Project gelesen und ausgewertet werden. Desweiteren kann man die Archivierung der Seite mit “noarchive” verbieten. Das ist sehr nützlich für die Archiv-Seiten des Blogs, damit Suchmaschinen diese nicht auch archivieren. Schließlich kann man noch die Indexierung einer Seite mit “noindex” verbieten. Seiten, wie “404 Not Found” oder Seiten mit Suchergebnissen kann man von der Indexierung von Suchmaschinen ausschließen.

Die folgenden Meta-Anweisungen sind für Wordpress optimiert und müssen nur in die Datei header.php in den -Bereich eingefügt werden:

    // Index all Single Posts, Pages and Categorys
     if(is_single() || is_page() || is_category() || is_home()) { ?>
        
     } ?>
 
    // Do not archive the archive
     if(is_archive()) { ?>
        
     } ?>
 
    // Do not index the search results and the 404 pages
     if(is_search() || is_404()) { ?>
        
     } ?>

Die Anweisungen bewirken, dass Suchmaschinen nicht die Einträge des Open Directory Project als Quelle für Titel und Beschreibung des Blogs benutzen. Außerdem werden die Blog-Archive nicht von den Suchmaschinen archiviert und 404-Seiten sowie Suchergebnis-Seiten werden von der Indexierung ausgenommen. [via askapache.com]

Wordpress SEO: robots.txt

ni.c — Sat, 08 Nov 2008 17:56:54 +0000

Heute habe ich mich ein wenig mit Suchmaschinenoptimierung beschäftigt und festgestellt, dass Google doch sehr viel doppelten Content aus diesem Blog indexiert. Doppelter Content ist von Google nicht so gerne gesehen und kann zu einer schlechteren Plazierung in den Suchergebnissen führen. Deshalb sollte man dem Googlebot mitteilen, was er indizieren darf und was nicht.

Um das zu ermöglichen, gibt es den Robots Exclusion Standard. Nach diesem Standard muß man eine Textdatei mit dem Namen robots.txt erstellen und diese im Stammverzeichnis der Domain plazieren, so daß Robots sie finden. Die Suchpfade sehen dann z.B. so aus:

http://www.beispiel.de/robots.txt


http://download.beispiel.de/robots.txt

http://beispiel.de:8080/robots.txt

Nun habe ich mir die Ordnerstruktur meines Wordpress-Blogs angesehen, und dabei eine robots.txt erstellt, die für alle Wordpress Blogs recht nützlich sein sollte.

Zuerst teilen wir allen Robots mit, wo sich die Datei sitemap.xml befindet und verbieten die Indexierung der Wordpress-Verzeichnisse und der Trackback-Links.

User-agent: *
Sitemap: http://www.[url].de/sitemap.xml
 
# disallow all files in these directories
Disallow: /cgi-bin/
Disallow: /wp-admin/
Disallow: /wp-includes/
Disallow: /wp-content/themes/
Disallow: /wp-content/plugins/
Disallow: /trackback/
Disallow: /*?*
Disallow: */trackback/

Dem Googlebot verbieten wir die Indexierung aller PHP und sonstigen Dateien sowie des kompletten wp-content Verzeichnisses, bis auf den darin enthaltenen Order uploads.
Außerdem verbieten wir die Indexierung der Seiten für die Kategorien und Tags des Blogs, da sich darin der doppelte Content befindet.

User-agent: Googlebot
# disallow all files ending with these extensions
Disallow: /*.php$
Disallow: /*.js$
Disallow: /*.inc$
Disallow: /*.css$
Disallow: /*.gz$
Disallow: /*.cgi$
Disallow: /*.wmv$
Disallow: /*.png$
Disallow: /*.gif$
Disallow: /*.jpg$
Disallow: /*.cgi$
Disallow: /*.xhtml$
Disallow: /*.php*
Disallow: */trackback*
Disallow: /*?*
Disallow: /category/
Disallow: /tag/
Disallow: /wp-*
Allow: /wp-content/uploads/

Dem Googlebot für die Bildersuche geben wir vollen Zugriff auf alle Verzeichnisse:

# allow google image bot to search all images
User-agent: Googlebot-Image
Allow: /*

Der AdSense-Bot darf ebenfalls die gesamte Seite bis auf wp-admin und wp-includes indexieren:

# allow adsense bot on entire site
User-agent: Mediapartners-Google*
Disallow: /*?*
Allow: /wp-content/
Allow: /tag/
Allow: /category/
Allow: /*.php$
Allow: /*.js$
Allow: /*.inc$
Allow: /*.css$
Allow: /*.gz$
Allow: /*.cgi$
Allow: /*.wmv$
Allow: /*.cgi$
Allow: /*.xhtml$
Allow: /*.php*
Allow: /*.gif$
Allow: /*.jpg$
Allow: /*.png$

Anschliessend verbieten wir noch die Archivierung des Blogs:

# disallow archiving site
User-agent: ia_archiver
Disallow: /
 
# disable duggmirror
User-agent: duggmirror
Disallow: /

Herausgekommen ist nun eine für Wordpress-Blogs optimierte robots.txt:

User-agent: *
Sitemap: http://www.[url].de/sitemap.xml
 
# disallow all files in these directories
Disallow: /cgi-bin/
Disallow: /wp-admin/
Disallow: /wp-includes/
Disallow: /wp-content/themes/
Disallow: /wp-content/plugins/
Disallow: /trackback/
Disallow: /*?*
Disallow: */trackback/
 
User-agent: Googlebot
# disallow all files ending with these extensions
Disallow: /*.php$
Disallow: /*.js$
Disallow: /*.inc$
Disallow: /*.css$
Disallow: /*.gz$
Disallow: /*.cgi$
Disallow: /*.wmv$
Disallow: /*.png$
Disallow: /*.gif$
Disallow: /*.jpg$
Disallow: /*.cgi$
Disallow: /*.xhtml$
Disallow: /*.php*
Disallow: */trackback*
Disallow: /*?*
Disallow: /category/
Disallow: /tag/
Disallow: /wp-*
Allow: /wp-content/uploads/
 
# allow google image bot to search all images
User-agent: Googlebot-Image
Allow: /*
 
# allow adsense bot on entire site
User-agent: Mediapartners-Google*
Disallow: /*?*
Allow: /wp-content/
Allow: /tag/
Allow: /category/
Allow: /*.php$
Allow: /*.js$
Allow: /*.inc$
Allow: /*.css$
Allow: /*.gz$
Allow: /*.cgi$
Allow: /*.wmv$
Allow: /*.cgi$
Allow: /*.xhtml$
Allow: /*.php*
Allow: /*.gif$
Allow: /*.jpg$
Allow: /*.png$
 
# disallow archiving site
User-agent: ia_archiver
Disallow: /
 
# disable duggmirror
User-agent: duggmirror
Disallow: /

Diese Datei sollte man noch an die eigenen Bedürfnisse anpassen und um die Einträge der Verzeichnisse der installierten Plugins erweitern. Zum Beispiel:

Flickr Photo Album

Disallow: /photos/tags/
Disallow: /photos/photo/

WP Super Cache

Disallow: /wp-content/cache/
Disallow: /wp-content/advanced-cache.php/

Bei Fehlern, Kritik und Verbesserungsvorschlägen freue ich mich über Anmerkungen in den Kommentaren. Aber nun heißt es erstmal abwarten auf Pagerank 10.

download: lastgraph.zip (2.96MB)
added: 26/05/2009
clicks: 257
description: My last.fm History