Exoplaneten: Kepler findet Unmengen erdgroßer Planeten

Bahnt sich hier eine kleine Sensation an:

Exoplaneten: Kepler findet Unmengen erdgroßer Planeten - Sterne und Weltraum

Nach diesen Ergebnissen hat jeder 1000ste Stern in der Milchstraße einen Planeten von der Größe der Erde.
Bei geschätzten 100 Milliarden Sternen in unserer Galaxie ergibt das 100 Millionen Planeten von der Größe der Erde.
Setzt man jedoch den Wert von 1/1000 als die Anzahl der Sterne mit erdähnlichen Planeten in die Drake-Gleichung ein, so ergibt sich trotzdem eine ernüchternd niedrige Anzahl von außerirdischen Zivilisationen in unserer Milchstrasse mit denen ein Kontakt möglich wäre:

N=R* f_p * n_e *f_L * f_i * f_C * L

mit

R = 10/y (Sternenstehungsrate: Abschätzung über Anzahl Sterne in Milchstrasse 10ˆ11 / 10ˆ10 y Alter des Universums)
f_p * n_e = 1/1000 (Wahrscheinlichkeit für Planeten von Erdgröße aus den Kepler-Messungen)
f_L = 2/10 (Wahrscheinlichkeit für die Entstehung von Leben)
f_i = 1/100 (Wahrscheinlichkeit für intelligentes Leben)
f_C =1/100 (Wahrscheinlichkeit für Leben mit Interesse an Kommunikation)
L = 10000y (Lebensdauer einer technischen Zivilisation)

Mit den obigen Faktoren (übernommen aus Drake Equation) ergibt sich

N = 1/500

D.h. die Anzahl der außerirdischen Zivililisationen in der Milchstrasse mit denen wir kommunizieren könnten ist weit weniger als 1. Auf das ganze Universum hochgerechnet (100 Milliarden milchstrassenähnliche Galaxien) ergibt sich N=200 Millionen, also etwa eine Zivilisation pro Galaxienhaufen. Die Entfernung zur nächsten Zivilisation liegt nach diesen Abschätzungen dann etwa bei 1-10 Millionen Lichtjahren. Das ist verdammt weit und ein Kontakt praktisch unmöglich. Das würde erklären, warum wir bisher noch keinen Außerirdischen begegnet sind.
Allerdings ist die Drake-Gleichung natürlich nicht wirklich ernstzunehmen: die richtigen Faktoren f_L, f_i, f_C und L sind völlig unbekannt, Drake hat die oben angegebenen Werte einfach geschätzt. Statt der Drake-Gleichung könnte man auch die Gleichung der Rare-Earth-Hypothese benutzen. Schlauer wird man davon aber auch nicht, denn auch dort sind die meisten Faktoren ziemlich willkürlich angesetzt.
Also kann man trotz der vielen erdähnlichen Planeten nicht wirklich etwas über die Anzahl außerirdischer Zivilisationen sagen. Allerdings besteht eine Wahrscheinlichkeit von 1, dass im Umkreis von 100 Lichtjahren (etwa 1000 Sterne), ein erdähnlicher Planet existiert. Diesen könnte man theoretisch gerade so in der Lebenspanne eines Menschen erreichen, wenn man mit Lichtgeschwindigkeit reist.

UPDATE: Inzwischen ist der erste annähernd erdähnliche Planet in 600 Lichtjahren gefunden worden: Kepler 22b, siehe http://www.spiegel.de/wissenschaft/weltall/0,1518,801916,00.html oder mit Link zum Orginalartikel der Nasa http://www.kurzweilai.net/nasas-kepler-confirms-its-first-planet-in-habitable-zone-of-sun-like-star.

Flask unter Mac OS X 10.6 installieren und testen

Flask (A Python Microframework) ist ein äußerst vielversprechendes sogenanntes Mikro-Framework zur Entwicklung von Python Webapplikationen. Nach der Installation von mod_wsgi (Siehe meinen vorhergehenden Post Installation von mod_wsgi unter Mac OS X 10.6), steht dem Einsatz von Flask unter Mac OS X nichts mehr im Wege. Ich gehe im folgenden davon aus, das Python 2.6 und die Python Setuptools bereits mit MacPorts installiert sind. Dann sollte man

1. Das richtige easy-install-Kommando auswählen
> which easy_install-2.6
/opt/local/bin/easy_install-2.6

2. Flask installieren
> sudo easy_install-2.6 flask

3. Eine Beispielapplikation schreiben:
> pico helloflask.py
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello_flask():
return "Hello Flask!"

if __name__ == "__main__":
app.run()

> pico hello.wsgi
import sys
sys.path.append("/Users/username/Sites/webapp")
from helloflask import app as application

4. Beide Dateien hello.wsgi und helloflask.py sollte man dann in /Users/username/Sites/webapp ablegen, welches das konfigurierte WSGIScriptAlias Verzeichnis des Virtual Host mydomain.org sein sollte (Siehe Installation von mod_wsgi unter Mac OS X 10.6).

5. mydomain.org aufrufen:
Ist alles gut gegangen begrüsst uns unsere erste Flask Webapplikation beim Aufruf von mydomain.org im Browser mit "Hello Flask!".

Installation von mod_wsgi unter Mac OS X 10.6

Ich wollte endlich mal mod_wsgi zur Entwicklung von Python Webapplikationen auf meinem Mac Mini ausprobieren. Die Installation von mod_wsgi mit Hilfe von MacPorts erwies sich dabei als sehr einfach. Die anschliessende notwendige Konfiguration von Apache2 ist aber aufwendig genug, so dass ich sie hier mal im Detail beschreiben möchte:

0. Unter Systemeinstellungen/Freigabe die Webfreigabe deaktivieren um den von Apple in Mac OS X mitgelieferten Apache2 Server zu deaktivieren.

1. Installation von mod_wsgi mit MacPorts:
> sudo port install mod_wsgi
Falls noch nicht vorhanden, wird Apache2 dabei mit installiert.

2. Starten und Testen von Apache:
> sudo /opt/local/apache2/bin/apachectl -k start
Nach dem Start von Apache kann man http://localhost mit dem Browser öffnen. Es sollte "It works!" angezeigt werden.

3. Apache beim Systemstart automatisch starten:
> sudo launchctl load -w /Library/LaunchDaemons/org.macports.apache2.plist

4. Aktivierung der Benutzerverzeichnisse, so dass Webseiten die unter http://localhost/~username/Sites liegen, angezeigt werden:
Dazu muss die Zeile
Include conf/extra/httpd-userdir.conf
in der Datei
/opt/local/apache2/conf/httpd.conf
einkommentiert werden. Dann in der Datei
/opt/local/apache2/conf/extra/httpd-userdir.conf
die Zeilen
#
# Include user configurations
#
Include /private/etc/apache2/users/*.conf
hinzufügen. Danach muss Apache2 neugestartet werden:
> sudo /opt/local/apache2/bin/apachectl -k restart

5. Aktivierung des mod_wsgi Moduls für Apache2:
Dazu muss die Zeile
LoadModule wsgi_module modules/mod_wsgi.so
zu der Datei
/opt/local/apache2/conf/httpd.conf
hinzugefügt werden. Danach wieder Apache neustarten.

6. Anlegen einer wsgi-Applikationen:
Zum Testen kann man erstmal folgende einfache wsgi-Applikation anlegen:
> pico hello.wsgi
import sys
def application(environ, start_response):
status = '200 OK'
output = 'Hello World!\n'
output+= str(sys.path)
response_headers = [('Content-type', 'text/plain'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)

return [output]

Sie gibt "Hello World!" zurück und zusätzlich die System-Pfade unter denen das wsgi-Modul nach Python-Modulen sucht (Siehe auch mod_wsgi - Quick Configuration Guide).

7. Einrichten eines Virtual Hosts für wsgi-Applikationen:
Dazu muss die Zeile
Include conf/extra/httpd-vhosts.conf
in der Datei
/opt/local/apache2/conf/httpd.conf
einkommentiert werden. In der Datei
die Zeilen
<VirtualHost *:80>
ServerName www.mydomain.org
ServerAlias mydomain.org
ServerAlias my.dyndns.org
ServerAdmin webmaster@mydomain.org

WSGIScriptAlias / /Users/username/Sites/webapp/hello.wsgi
WSGIScriptReloading On

<Directory /Users/username/Sites/webapp>
Order deny,allow
Allow from all
</Directory>
</VirtualHost>
einfügen. Dabei steht mydomain.org für den gewünschten Domainnamen, my.dyndns.org für einen eventuell vorhandenen dynamischen DNS - Eintrag. (Wie man Virtual Hosts noch besser mit DynDNS verwenden kann steht bei Virtual-Hosts und DynDNS zusammen einsetzen. Das dort angesprochene Wildcard-Feature kostet jedoch 15 $ im Jahr). WSGIScriptAlias gibt an, dass die Root-Adresse "/" des virtuellen Servers die wsgi-Applikation hello.wsgi
im Verzeichnis /Users/username/Sites/webapp aufruft. Während der Entwicklung macht es auch Sinn WSGIScriptReloading zu aktivieren, damit man nicht bei jeder Änderung an der wsgi-Applikation den Apache-Server neustarten muss. Mehr dazu im mod_wsgi - Quick Configuration Guide. Nach dem Konfigurieren des Virtualhosts muss der Apache-Server wieder neugestartet werden. Jedoch funktionieren die angegeben Domainnamen noch nicht. Dazu müssen erst noch in der Datei
/private/etc/hosts
die Zeilen
127.0.0.1 mydomain.org
127.0.0.1 www.mydomain.org
hinzugefügt werden (Siehe Creating a virtual host in Mac OS X 10.5 ).

8. Aufruf von http://mydomain.org bzw. http://www.mydomain.org mit dem Browser:
Wenn alles geklappt hat sollte man jetzt "Hello World!" im Browser sehen und darunter die Python-Systempfade.