blogoscoop

Jetzt bereits Google Wave testen

Posted by ni.c - 27/07/09 at 12:12 am

Google Wave

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.

PyGo Wave

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

Posted by ni.c - 01/07/09 at 10:59 pm

Keytweeter

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

Posted by ni.c - 21/05/09 at 1:24 am

Evolution of a Programmer

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 < 2; ++i)
      printf("%s", message[i]);
    printf("\n");
  }

Seasoned professional

  #include <iostream.h>
  #include <string.h>
 
  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 &gt;= 0) {
    while(defined($arg=shift(@ARGV))) {
      $outfilename = $arg;
      open(FILE, "&gt;" . $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

Posted by ni.c - 12/05/09 at 11:08 pm

iPhone

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.

iPhone Safari

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.

Handy Browser

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

Google Web Toolkit & MD5

Posted by ni.c - 11/05/09 at 11:19 pm

MD5
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.

http://www.ni-c.de/wp-content/plugins/downloads-manager/img/icons/default.gif download: Md5.java (6.84KB)
added: 12/05/2009
clicks: 223
description: A class to perform MD5 hashing in GWT with native JavaScript.

CeBIT: IBM erklärt Cloud Computing

Posted by ni.c - 02/03/09 at 6:26 pm

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

Posted by ni.c - 13/11/08 at 6:34 pm

Nach der Suchmaschinenoptimierung 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

Posted by ni.c - 12/11/08 at 9:18 pm

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:

<meta name="googlebot" content="noindex, nofollow" />

oder

<meta name="robots" content="noindex, nofollow" />

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:

<meta name="author" content="Autor" />
<meta name="keywords" content="Schlüsselwörter" />
<meta name="description" content="Seitenbeschreibung" />
<meta name="generator" content="HTML-Editor" />
<meta name="author" content="Name" />
<meta name="copyright" content="Name" />
<meta name="publisher" content="Name" />
<meta name="page-topic" content="Keywörter" />
<meta name="revisit-after" content="Anzahl Tage" />
<meta name="language" content="de" />
<meta name="content-language" content="de" />
<meta name="DC.title" content="Titel" />
<meta name="DC.creator" content="Autor" />
<meta name="DC.subject" content="Thema" />
<meta name="DC.description" content="Beschreibung" />
<meta name="DC.publisher" content="Publisher" />
<meta name="DC.contributor" content="Contributor" />
<meta name="DC.type" content="Text" scheme="DCTERMS.DCMIType" />
<meta name="DC.format" content="text/html" scheme="DCTERMS.IMT" />
<meta name="DC.language" content="de" scheme="DCTERMS.RFC3066" />
<meta name="DC.coverage" content="Germany" scheme="DCTERMS.TGN" />
<meta name="DC.rights" content="Lizenztyp" />
<meta http-equiv="Content-Script-Type" content="text/javascript" />
<meta http-equiv="Content-Style-Type" content="text/css" />
<meta http-equiv="content-language" content="de" />

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

Wordpress SEO: header.php Hack

Posted by ni.c - 09/11/08 at 4:36 pm

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
    <?php if(is_single() || is_page() || is_category() || is_home()) { ?>
        <meta name="robots" content="all,noodp" />
    <?php } ?>
 
    // Do not archive the archive
    <?php if(is_archive()) { ?>
        <meta name="robots" content="noarchive,noodp" />
    <?php } ?>
 
    // Do not index the search results and the 404 pages
    <?php if(is_search() || is_404()) { ?>
        <meta name="robots" content="noindex,noarchive" />
    <?php } ?>

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

Posted by ni.c - 08/11/08 at 7:56 pm

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.

http://www.ni-c.de/wp-content/plugins/downloads-manager/img/icons/winzip.gif download: lastgraph.zip (2.96MB)
added: 26/05/2009
clicks: 238
description: My last.fm History

This work is licensed under a Creative Commons License

Entries RSS | Comments RSS | Activities RSS | Site Admin

22 queries | 4.599 seconds