Category Archives: Allgemein

Tragt Fahrradhelme

Mein Fahrrad hat heute morgen gemeint, mich nicht mehr zu mögen. Das Vorderrad hat blockiert und mich vornüber geworfen. Wie man merkt, geht es mir ganz gut und bin mit einer Platzwunde am Kinn davon gekommen. Ich möchte aber nicht wissen, wie es mir gehen würde, wenn ich keinen Helm getragen hätte, denn ich bin auf den Kopf gestürzt.

Daher einfach an alle: tragt bitte einen Fahrradhelm. Egal wie sicher ihr euch auf dem Fahrrad fühlt – es gibt immer auch unaufmerksame Autofahrer oder nachlassendes Material, wie in meinem Fall. Ach und auch wichtig: neuen Fahrradhelm kaufen nach jedem Sturz (ich lasse jetzt mein Fahrrad stehen bis ich einen neuen habe (das Fahrrad mit dem ich gestürzt bin, wird verschrottet)).

=-=-=-=-=
Powered by Blogilo

Studium Vorbei

Heute war das letzte große Ereignis meines Studiums: Abschlussvortrag mit anschließender mündlicher Prüfung. Nun warte ich nur noch auf die Note für die Masterarbeit :-) Zumindest gibt es nur noch zwei Möglichkeiten für die Endnote, wer wissen will, welche darf gerne persönlich nachfragen ;-)

Nun ist also das schöne Studentenleben vorbei und nach Ostern beginnt der Ernst des Lebens. Bin ja mal gespannt

=-=-=-=-=
Powered by Blogilo

Abklappern der Copyshops

Woran merkt man, dass man mit der Abschlussarbeit fast fertig ist? Man holt Samstags Kostenvoranschläge für den Druck der fünf Exemplare ein. Die Preise waren so heftig, dass ich den Anhang komplett noch einmal in schwarz/weiß generiert habe. Am Montag werde ich das Werk dann wohl in den Druck geben, so dass ich entweder am Dienstag oder Mittwoch die Arbeit abgeben kann. Müsste erst am Mittwoch, aber mittlerweile hab ich einfach keine Lust mehr daran zu arbeiten und fürchte, dass ich entweder verkorrigiere oder das Layout zerstöre.

Insgesamt 183 Seiten habe ich zu Papier gebracht, ohne den bloat (Verzeichnisse, Anhang) immer noch 106 Seiten. Darunter sind 39 Abbildungen, 11 Tabellen und 26 Listings. Insgesamt fast 6 Monate hab ich daran gearbeitet, seit Anfang Januar aber keinen Quellcode mehr geschrieben und meine Implementierung im Produktiveinsatz getestet. Allein im Januar hat der Filter 416 Spammails rausgeholt – im Februar deutlich mehr (zumindest zeigte die Tendenz bis zum 15.02. dies an – der Vallentinstag).

Neben den 41.000 Wörtern (laut wc) im Dokument, hab ich laut sloccount etwa 8.000 Zeilen Code geschrieben (UI nicht mitgezählt). Sloccount meint, man bräuchte dafür etwa 1,5 Personenjahre und die Entwicklung würde mehr als USD 200.000 in kommerzieller Entwicklung kosten. Naja das Tool liefert komische Werte ;-) Meine Einschätzung vor der Arbeit war, dass ich zwischen 5.000 und 10.000 Zeilen Code schreiben kann in der kurzen Zeit. Das hab ich dann doch ziemlich genau getroffen. Gut war einfach hochzurechnen, da ich ja weiß wieviel ich für KDE geschrieben habe in vergleichbaren Zeitspannen (Alt+Tab hat 2,6 KSLOC, Aurorae hat 1,9 KSLOC, Cube hat 3,2 KSLOC).

=-=-=-=-=
Powered by Blogilo

How to write a KWin effect

This blog post has been in my drafts folder for weeks and I just thought it’s time to publish it – ready for Akademy :-) And if somebody is really interested we could have a BOF session at Akademy. I think Plasma devs want us to write a slide effect to replace their custom popup animation. That would be a perfect example to get your hands dirty.

I wrote a new Kwin effect and thought this is the ideal effect for writing a small howto. It is an effect which helps resizing windows by colouring the changed geometry. I was told that resizing is not optimal in KWin, that is if the window content is shown while resizing it is slow and if the window content is not shown it is ugly. This effect should fill the gap. Unfortunately the current code will only work with the slow show window content while resizing (the API has to be changed). Nevertheless I decided to show the code in this tutorial.

Von KWin

The effect has been committed to trunk. So you can have a look at it and if you’re running trunk you can even try it. The effect which we will write has the name “Resize”. It will support both backends: XRender and OpenGL. Each effect has an own directory in kwin/effects so we create a new directory resize. There we create the following files:

  • CMakeLists.txt
  • resize.h
  • resize.cpp
  • resize.desktop

We have to include this directory into the build, so we edit the CMakeLists.txt in the effects directory. We just add the following line to the section marked as “Common effects”:

include( resize/CMakeLists.txt )

If it were an OpenGL only effect we would place this line in the section marked as “OpenGL-specific effects”.

So at this point we are finished with the preparation. So let’s start looking at the files. First the desktop file:

[Desktop Entry]
Name=Resize Window
Icon=preferences-system-windows-effect-resize
Comment=Effect to outline geometry while resizing a window

Type=Service
X-KDE-ServiceTypes=KWin/Effect
X-KDE-PluginInfo-Author=Martin Gräßlin
X-KDE-PluginInfo-Email=kde@martin-graesslin.com
X-KDE-PluginInfo-Name=kwin4_effect_resize
X-KDE-PluginInfo-Version=0.1.0
X-KDE-PluginInfo-Category=Window Management
X-KDE-PluginInfo-Depends=
X-KDE-PluginInfo-License=GPL
X-KDE-PluginInfo-EnabledByDefault=false
X-KDE-Library=kwin4_effect_builtins
X-KDE-Ordering=60

Most of it is self explaining and just needed for the “All effects” tab in the compositing kcm. The most important value is the “X-KDE-PluginInfo-Name”. This is the name used to load the effect and has to start with “kwin4_effect_” followed by your custom effect name. This last part will be needed in the source code.

Each effect is a subclass of class Effect defined in kwineffects.h and implements some of the virtual methods provided by Effect. There are methods for almost everything the window manager does. So by implementing those methods you can react on change of desktop or on opened/closed windows. In this effect we are interested in resize events so we have to implement method “windowUserMovedResized( EffectWindow *w, bool first, bool last )”. This method is called whenever a user moves or resizes the given window. The two boolean values indicate if it is the first, last or an intermediate resize event.

But there are more methods we have to implement. The effect should paint the changed geometry while resizing. So we have to implement the methods required for custom painting. KWin’s painting pass consists of three stages:

  1. pre paint
  2. paint
  3. post paint

These stages are executed once for the complete screen and once for every window. All effects are chained and each effect calls the stage for the next effect. How this works we will see when looking at the implementation. You can find a good documentation in the comments of scene.cpp

Now it’s time to have a look at the header file:

#ifndef KWIN_RESIZE_H
#define KWIN_RESIZE_H

#include <kwineffects.h>

namespace KWin
{

class ResizeEffect
    : public Effect
    {
    public:
        ResizeEffect();
        ~ResizeEffect();
        virtual void prePaintScreen( ScreenPrePaintData& data, int time );
        virtual void paintWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data );
        virtual void windowUserMovedResized( EffectWindow *w, bool first, bool last );

    private:
        bool m_active;
        EffectWindow* m_resizeWindow;
        QRegion m_originalWindowRect;
    };

}

#endif

We see that there are three member variables. The boolean is used to indicate if there is a window being resized, that is if we have to do some painting. The EffectWindow is a pointer on the window being resized and the QRegion stores the windows’s geometry before the start of resizing.

So now we can have a look at the implementation. I will split the code in small parts and explain the code. So first let’s look at the includes:

#include "resize.h"

#ifdef KWIN_HAVE_OPENGL_COMPOSITING
#include <GL/gl.h>
#endif                                               
#ifdef KWIN_HAVE_XRENDER_COMPOSITING                 
#include <X11/Xlib.h>
#include <X11/extensions/Xrender.h>
#endif                                                                

#include <KColorScheme>

As our effect should support both XRender and OpenGL we have to include the headers for both. As it is possible that the effect is compiled on a system which does not support one of both we use ifdef. We can be sure that at least one of both is available or the effects wouldn’t be compiled at all. If you write an OpenGL only effect you do not have to bother about such things. Also if you only use KWin’s high level API you don’t need to include those headers. But we want to paint on the screen using OpenGL or XRender directly.

So let’s have a look at the next part:

namespace KWin
{                    

KWIN_EFFECT( resize, ResizeEffect )                                                                                                                                                            

ResizeEffect::ResizeEffect()
    : m_active( false )                                                                                                                                    
    , m_resizeWindow( 0 )                                                                                                                                         
    {                                                                                                                           
    reconfigure( ReconfigureAll );                             
    }                                                                                                                           

ResizeEffect::~ResizeEffect()
    {                                                                                         
    }

Here we see the use of a macro. This has to be included or your effect will not load (it took me ten minutes to notice I forgot to add this line). The first value is the second part of X-KDE-PluginInfo-Name – I told you we will need it again. The second value is the class name. Following is constructor and deconstructor.

So let’s look at the pre paint screen stage:

void ResizeEffect::prePaintScreen( ScreenPrePaintData& data, int time )
    {                                                                                                                           
    if( m_active )                                             
        {                                                                                                                       
        data.mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS;           
        }                                                                                                                       
    effects->prePaintScreen( data, time );                                                                                                                     
    }

Here we extend the mask to say that we paint the screen with transformed windows when the effect is active. That’s not completely true – we don’t transform a window. But this flag indicates that the complete screen will be repainted, so we eliminate the risk of artefacts. We could also track the parts which have to be repainted manually but this would probably be more work for the CPU than the complete repaint for the GPU. At this point we see the chaining for the first time. The effects->prePaintScreen( data, time ); will call the next effect in the chain. effects is a pointer on the EffectsHandler and a very useful helper.

So now we start looking at the heart of the effect:

void ResizeEffect::paintWindow( EffectWindow* w, int mask, QRegion region, WindowPaintData& data )              
    {                                                                                                                           
    effects->paintWindow( w, mask, region, data );                                                   
    if( m_active && w == m_resizeWindow )                                                                                                                 
        {                                                                                                                       
        QRegion intersection = m_originalWindowRect.intersected( w->geometry() );                                                                                                                
        QRegion paintRegion = m_originalWindowRect.united( w->geometry() ).subtracted( intersection );                                                                                                                                                          
        float alpha = 0.8f;                                                                                                                                              
        QColor color = KColorScheme( QPalette::Normal, KColorScheme::Selection ).background().color();

We first continue the paint window effect chain – this will paint the window on the screen. Now we check if we are in resizing mode (m_active) and if the currently painted window is the window which is repainted. In that case we calculate the region which has to be painted. We just subtract the intersection of current geometry with saved geometry from the union of those two. The next two lines are for the color definition. We use the background color of a selection with 80 % opacity.

Now we have to do a little bit OpenGL. In most effects where you just transform windows you don’t have to write OpenGL at all. There is a nice high level API which allows you to translate, scale and rotate windows or the complete screen. Also transforming single quads can be completely done without knowing anything about OpenGL.

#ifdef KWIN_HAVE_OPENGL_COMPOSITING
        if( effects->compositingType() == OpenGLCompositing)                                  
            {                                                                                                                   
            glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT );                                                                                                                                    
            glEnable( GL_BLEND );                              
            glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );                                                                                                                               
            glColor4f( color.red() / 255.0f, color.green() / 255.0f, color.blue() / 255.0f, alpha );                                                                                                                      
            glBegin( GL_QUADS );                               
            foreach( const QRect &r, paintRegion.rects() )                                                                                                  
                {                                                                                                               
                glVertex2i( r.x(), r.y() );                                                                                                                                                  
                glVertex2i( r.x() + r.width(), r.y() );           
                glVertex2i( r.x() + r.width(), r.y() + r.height() );                                
                glVertex2i( r.x(), r.y() + r.height() );          
                }                                                                                                               
            glEnd();                                                                        
            glPopAttrib();                                                                  
            }                                                                                                                   
#endif

We check if KWin uses OpenGL as a backend. We enable blending in the OpenGL state machine (needed to have translucent colors) and set the color for our rects. OpenGL clamps colors in the range [0,1] that’s why we can’t use the values from QColor directly. Last but not least we just paint one quads for each rect of our regin.

Now just the XRender part is missing. This part is taken from show paint effect – I don’t know anything about XRender ;-)

#ifdef KWIN_HAVE_XRENDER_COMPOSITING
        if( effects->compositingType() == XRenderCompositing)                                 
            {                                                                                                                   
            XRenderColor col;                                                                      
            col.alpha = int( alpha * 0xffff );                                                                 
            col.red = int( alpha * 0xffff * color.red() / 255 );                       
            col.green = int( alpha * 0xffff * color.green() / 255 );                   
            col.blue= int( alpha * 0xffff * color.blue() / 255 );                      
            foreach( const QRect &r, paintRegion.rects() )                                                                                                  
                XRenderFillRectangle( display(), PictOpOver, effects->xrenderBufferPicture(),                                                                                                                          
                    &col, r.x(), r.y(), r.width(), r.height());
            }
#endif
        }
    }

This does the same as the OpenGL part just with XRender.

Last but not least we have to track the window resizing:

void ResizeEffect::windowUserMovedResized( EffectWindow* w, bool first, bool last )
    {
    if( first && last )
        {
        // not interested in maximized
        return;
        }
    if( first && w->isUserResize() && !w->isUserMove() )
        {
        m_active = true;
        m_resizeWindow = w;
        m_originalWindowRect = w->geometry();
        w->addRepaintFull();
        }
    if( m_active && w == m_resizeWindow && last )
        {
        m_active = false;
        m_resizeWindow = NULL;
        effects->addRepaintFull();
        }
    }

} // namespace

So and that’s all. When a resize event is started we activate the effect and trigger a repaint of the window (probably not needed, but doesn’t hurt). And when the resizing is finished we deactivate the effect and trigger another repaint of the complete screen just to make sure that there are no artefacts left.

The CMakeLists.txt could just be taken from any other effect and be adjusted. So here’s the example:

#######################################
# Effect

# Source files
set( kwin4_effect_builtins_sources ${kwin4_effect_builtins_sources}
    resize/resize.cpp
    )

# .desktop files
install( FILES
    resize/resize.desktop
    DESTINATION ${SERVICES_INSTALL_DIR}/kwin )

#######################################
# Config

Now you can compile and try your new effect.

Urlaub und Semesterbeginn

Letzte Woche hatte ich endlich – nach vier Jahren – mal wieder eine Woche Urlaub. Bin mit ein paar Freunden/Bekannten nach Paris gefahren. War sehr schön und sehr erholend. Leider war das Wetter nicht ganz so toll mit der Auswirkung, dass ich mir einen leichten Schnupfen eingefangen habe.

Einige Empfhelungen/Erfahrungen, die ich gemacht habe:

  • Auf den Eifelturm kurz vor der Dämmerung hochfahren. So sieht man die Stadt sowohl im Hellen als auch im Dunkeln und das ist einfach nur schön.
  • Wenn man bei den Tuilerien den Triumphbogen sieht und denkt, so weit ist das nicht, sollte man daran denken, dass der Bogen 50 m hoch ist und ja die Straße ist lang
  • Die Mona Lisa ist etwas enttäuschend. Man kommt nicht wirklich nah dran und im Panzerglas vor dem Bild spiegeln sich die Lampen. Abgesehen davon hat der Louvre ein schönes Café, in dem sich die nicht Kunstinteressierten verstecken können, bis der Zeitpunkt zum Treffen mit der Gruppe erreicht ist.
  • Louvre und auch Versaille erschienen mir vom Gebäude her kleiner als das Mannheimer Schloß (Architektonisch definitiv: das Mannheimer Schloß hat ein Fenster mehr als das Versailler). Zumindest von außen finde ich persönlich das Mannheimer Schloß auch schöner. Von innen kenne ich in Mannheim halt nur die Vorlesungssäale und die sind nicht mit Gold verzirt. Muss jetzt doch mal das Schloßmuseum besuchen.
  • Geht einer in das Restaurant und fragt nach Plätzen für sieben Personen und ruft den Rest danach mit “Allez les enfantes”, dann muss man sich nicht wundern, wenn der Tisch zu einem Kindertisch verwandelt wird.
  • Wenn am Bahnhof sich eine Person von der Gruppe entfernt und das Gepäck stehen lässt, während der Rest der Gruppe sich gemeinschaftlich zum Zug begibt, dann muss man sich nicht wundern, dass das nun herrenlose Gepäck von Soldaten umstellt wird (nein ich hatte nicht mein Gepäck stehen lassen).
  • Man kann mit Latein doch mehr Französich lesen als ich erwartet hatte.
  • Wenn Martin Hunger hat, sollte er essen. Warten führt zu dem unangenehmen Effekt, dass der Magen sich irgendwie weigert Essen aufzunehmen. Man hat dann gleichzeitig Hunger und Sättigungsgefühl beim Essen. Macht die ganze Sache dann nur noch schlimmer.
  • Ein Internettablet dabei zu haben ist ganz praktisch. Vor allem OpenStreet Map mit GPS macht sich gut ;-)

Da der Urlaub nun vorbei ist, hat man wieder Zeit zum Studieren. Heute war Vorlesungsbeginn in Mannheim und wie es sich für gute Studenten gehört, hatte ich heute keine Vorlesungen. Ändert sich leider sobald in Heidelberg das Semester beginnt. Insgesamt ist mein Vorlesungsplan doch etwas voll geworden. Muss mich jeden Tag an die eine oder die ander Uni quälen. Neues Semester heißt auch, dass ich jetzt wieder mit Lernen beginnen muss, da ich Ende des Monats noch eine Prüfung zum letzten Semester habe.

Das ewige gehupe – oder warum mich die EM solangsam annervt

Wie einige wohl wissen, wohne ich in der Mannheimer Innenstadt. Wie allgemein auch bekannt ist, gibt es in Mannheim sehr viele Mitbürger, die aus anderen europäischen Ländern stammen oder aus Ländern, die man bei bestimmten Wettbewerben zu Europa dazu zählt. Wie auch bekannt, findet zur Zeit solch ein bestimmter Wettbewerb, die Euro 2008, statt.

Nachdem sich die Vorrunde nun zu Ende neigt, beginnen die Spiele um 20:45 Uhr. Also enden sie gegen 22:40 Uhr mit der obligatorischen Nachspielzeit. Der ideale Zeitpunkt um die Autos zu besteigen in die Innenstadt zu fahren und kräftig auf die Hupe zu drücken. Man hat auch Ausdauer: eine halbe Stunde? eine Stunde? zwei Stunden? Alles kein Problem. Interessiert es mich, dass es in Mannheim auch Menschen gibt, die um 01:00 Uhr Nachts schlafen und nicht gehupe hören wollen? Vielleicht, aber unsere Mannschaft hat doch gewonnen!

Angefangen hat alles mit dem Spiel Schweiz gegen Türkei. In der Nachspielzeit erzielen die Türken den Siegtreffer: das ist ein Nationalereignis: “Ja wir haben einen Sieg”. Hat man zu dem Zeitpunkt schon etwas erreicht? Nein – ein Sieg im zweiten Spiel, noch nicht für das Viertelfinale qualifiziert. Trotzdem das muss gefeiert werden.

Dank des italienischen Unentschieden und der deutschen Niederlage hatte man in Mannheim erst mal wieder Ruhe. Bis, nun ja, bis die Türken wieder spielten. Sie lagen bereits 2:0 zurück gegen stark spielende Tschechen. Man freute sich auf eine ruhige Nacht… und was passiert: der tschechische Torwart greift daneben und die Türkei dreht das Spiel und qualifiziert sich für das Viertelfinale. An dem Punkt etwas erreicht? Den Titel gewonnen? Trotzdem ein Grund zu feiern – wieder eine schlaflose Nacht.

Nächster Abend: Deutschland gegen Österreich. Deutschland spielt schlecht, schwach. Das Highlight der Rausschmiss der Trainer auf die Tribüne. Deutschland gewinnt und qualifiziert sich auch für das Viertelfinale. Stellt das Erreichen des Viertelfinales wirklich ein für Deutschland bereits angemessenes Ziel da? Ist alles unter Erreichen (falls Deutschland nicht weiter kommt) des Finales nicht eine Niederlage? Gibt es also einen Grund zu hupen? Dennoch – man muss ja zeigen, dass die deutsche Bevölkerung mit den Türken es aufnehmen kann. Die Herausforderung wurde angenommen – auch wenn beim Lautstärkeduell klar die Türken (noch) vorne sind.

Dienstag: Man freut sich – heute gibt es für keine Minorität einen Grund zu feiern. Holland wird schön brav verlieren (sind ja sicher Gruppensieger) und Italien und Frankreich fahren nach Hause. Tja Rechnung geht nicht auf: Holland gewinnt, Italien gewinnt. Italien qualifiziert sich ebenfalls für das Viertelfinale. Ist das Erreichen des Viertelfinales wirklich ein Grund zu feiern, wenn man von Holland abgeschlachtet wurde (im ersten Spiel) und man amtierender Weltmeister ist? Offensichtlich ja: es wurde wieder gehupt.

Heute: ja heute: Es spielt Griechenland, Spanien, Rußland und Schweden. Meine Hoffnung liegt darin, dass die Minoritäten zu klein sind um mich wach zu halten…

Und die Zukunft: Morgen spielt Deutschland. Übermorgen die Türkei. Hoffnung: der türkische Torwart ist gesperrt – er war gegen Tschechien klar der beste Mann. Ja die Hoffnung stirbt zu Letzt. Liebe Kroaten schmeißt die Türken raus – ich möchte schlafen. Am Sonntag spielt Italien gegen Spanien. Auch hier gibt es Hoffnung – überzeugen konnte ja Italien bei dieser EM noch nicht.

Zum Glück ist am Dienstag – am Tag vor einer Klausur – spielfrei. Da werde ich also schlafen können. Und dann nur noch drei Partien… Es gibt Hoffnung auf ruhige Nächte – und wenn Deutschland gewinnt: dann muss ich auch nicht schlafen ;-)

Martin ist zu dumm…

… auf Worpress 2.5 upzugraden :-(
Ich hab wp-content anstatt vom backup ins neue WordPress, vom neuen ins backup kopiert. Daher fehlen nun einige Bilder, etc. Ich hoffe noch ein altes Backup zu finden und werde in Zukunft auch das WordPress Verzeichnis in mein Backup Skript miteinschließen ;-)

Also hier läuft jetzt auch WordPress 2.5. Fehler, die sich nicht aus obigem erklären, bitte melden.

Ich sehe grau

Ich habe einen neuen Monitor gekauft und kann endlich Graustufen erkennen :-) Es war fürchterlich. Gerade in KDE 4 konnte ich überhaupt keine Übergänge erkennen. Jetzt kann ich es richtig genießen.

Und nie wieder kaufe ich irgendetwas technisches bei einem Discounter :-(

Open Source Geschäftsmodell

Ich hatte vor einiger Zeit mal eine ausführliche Diskussion mit einem VWL-Studenten über das Open Source Geschäftsmodell. Ich hatte versprochen, dass ich mal in meinem Blog meine Sicht zu Open Source in der Wirtschaft niederschreibe und warum das Ganze überhaupt funktioniert. Natürlich habe ich keine Ahnung von VWL, BWL und keinen Einblick in die Firmen, kann also nicht wissen, wie gut oder schlecht die verschiedenen Open Source Firmen dastehen.

Was ist Open Source?
Open Source ist eine seit 10 Jahren (Freie Software ~20 Jahre) in der Informatik existierende Bewegung, die ein konkurrierendes Geschäftsmodell zur klassischen Lizensierung von Software (Proprietäre Software) darstellt. Bei proprietärer Software erhält der Käufer (Anwender) nur eine eingeschränkte Benutzungslizenz. Es gibt verschiedene Bezahlungsmodelle. So ist es durchaus üblich für jede Version einmalig zu zahlen oder aber für die mit der Software erbrachte Rechenleistung (pro Jahr, pro Anzahl Prozessoren, etc.). Der Quellcode ist jedoch nicht in der Lizenz erhalten, der Käufer erhält meistens nur eine vorkompilierte, zum Teil angepasste Binärversion.

Bei Open Source liegt der Quelltext offen, wobei der Verkauf der Software nicht ausgeschlossen ist. So ist es durchaus möglich für die Bereitstellung der Open Source Software als Datenträger oder als Download Geld zu verlangen, jedoch müssen dem Nutzer bzw. Käufer einige grundlegende durch eine spezielle Softwarelizenz garantierte Freiheiten eingeräumt werden. Dazu gehört die Bereitstellung des Quellcodes und das Recht diesen zu verändern oder einfach nur weiterzugeben. Ein Käufer einer kostenpflichtigen Open Source Software hat also das Recht diese kostenfrei weiterzugeben. Daher ist in der Regel Open Source Software kostenlos erhältlich, die anfallenden Bereitstellungskosten werden anderweitig (z.B. Werbung) finanziert. Im Allgemeinen haben sich zwei Lizenzen in der Freien und Open Source Welt durchgesetzt: die GPL und Apache Lizenz. Die GPL ist die bedeutend striktere. Sie garantiert dem Benutzer, dass die Software auch in jeder zukünftigen Version unter der gleichen Lizenz stehen wird. Die Apache Lizenz ist pragmatischer und erlaubt auch den Einsatz in proprietärer Software oder in Verbindung mit anderen Lizenzen und ist daher im unternehmerischen Bereich beliebter.

Die Community
Um die meisten Open Source Projekte has sich eine sogenannte Community entwickelt. Diese entwickelt und supportet die Software. Die Community besteht meistens sowohl aus Firmen als auch aus freiwilligen Entwicklern, die ihre Freizeit dafür opfern. Warum Firmen dabei mitarbeiten, schauen wir uns später an. Für die Freiwilligen gibt es verschiedene Motivationsgründe:

  • Sie haben lange von der Software profitiert und wollen aus “Dankbarkeit” etwas zurückgeben
  • Sie wollen mithelfen das Produkt noch weiter zu verbessern, eigene Ideen einzubringen
  • Eine Möglichkeit die eigenen Kenntnisse im Rahmen eines professionellen Projekts zu verbessern
  • Durch die offene Mitarbeit sich selber profilieren und bessere Jobaussichten zu bekommen
  • viele weitere

Für mich als KDE Entwickler trifft eigentlich jeder der oberen Punkte zu. Der erste ist sicherlich der wichtigste, jedoch angesicht meines in absehbarer Zeit endendes Studiums ist auch der letzte Punkt durchaus ein wichtiger Motivationsfaktor.

Software, die in einem Community-Prozess entwickelt wird, ist von den Entwicklungskosten her bedeutend billiger als proprietäre Software. Trotzdem können “Nice-to-have” Features implementiert werden, da die Entwicklung der Software nicht das Geschäftsziel ist. Community Software enthält somit meistens mehr Features, ist in mehr Sprachen übersetzt, mehr usable als vergleichbare konkurrierende proprietäre Software. Dazu kommt, dass quelloffene Software von konkurrierenden quelloffenen Projekten durchaus profitieren kann, da es Code einfach austauschen kann.

Nun wollen wir uns den verschiedenen Geschäftsmodellen widmen.

Dual Lizensierung
Die Dual Lizensierung ist sicherlich das interessanteste und erfolgreichste Open Source Geschäftsmodell. Das vorzeige Projekt ist Suns MySQL. Die Software wird nicht in einem Community Prozess entwickelt, sondern ausschließlich von einer Firma. Das Copyright des Quelltextes liegt somit in der Hand der Firma und diese kann die Software unter verschiedene Lizenzen stellen (Änderungen durch die Community fließen nicht in die Software ein). Im Falle von MySQL wird eine proprietäre Lizenz angeboten und die GPL. Die GPL erzwingt, dass MySQL nur in Verbindung mit GPL-lizensierten Projekten verwendet werden kann. Für den einfachen Anwender (wie die vielen Webseiten) völlig ausreichend. Für große Open Source Projekte ebenfalls. So verwendet MediaWiki (die Engine der Wikipedia) MySQL, genauso wie die bekannte Blog-Software WordPress. Für Firmen ist dies jedoch nicht geeignet. Sie wollen in der Regel nicht die GPL und erwerben nun bei – in Zukunft – Sun eine Lizenz für MySQL. Der Vorteil dieses Modells ist, dass durch die kostenlose Variante die Software schnell zum Einsatz gelangen kann und auch bei Prototypen durchaus zum Einsatz kommt. Eine proprietäre Lizenz kann im Nachhinein immer noch gekauft werden. Dieser Ansatz ist so erfolgreich, dass im Januar Sun die Firma MySQL AB für $ 1 Mrd. gekauft hat. Im Februar hat Sun auch noch die Firma Innotek gekauft, und im Januar Nokia Trolltech. Ebenfalls zwei Firmen, die dieses Lizensierungsmodell verfolgen.

Support
Das zweite bekannte Modell ist das Support Modell. Firmen bieten kostenpflichtigen Support für Open Source Software an. So garantieren sie zum Beispiel Sicherheitsupdates bereitzustellen und helfen bei der Installation. Das Geld, das mit der Erbringung von Support erwirtschaftet wird, fließt in die Entwicklung der Open Source Software. Wir haben somit eine Trennung von Produkt und Finanzierung des Produkts. Das Produkt wird kostenfrei angeboten und dies wird über Support finanziert. Dazu kommt, dass die Software auch von der Community entwickelt wird. Die Firma also nicht so viel Entwicklungszeit finanzieren muss und einfach nur professionell leitend eingreifen muss. Für die Community stellt das keinen Konflikt da, da die Firmen nicht mit ihrem Quellcode Geld verdienen sondern mit einem Zusatzprodukt. Die Unterstützung durch die Firmen ist daher durchaus willkommen und auch gefordert. Prominente Beispiele dieses Modells sind RedHat und Canonical.

“Nebenprodukt”
Bei vielen großen IT-Firmen fällt Software im Rahmen eines internen Projekts als “Nebenprodukt” an. Ein klassisches Beispiel ist die Java Entwicklungsumgebung Eclipse, die von IBM entwickelt wurde. Die Firmen geben diese Produkte als Open Source frei um durch die Community eine weitere Verbesserung zu erhalten, wovon sie auch profitieren. Die Software betrifft nicht ihre Kernkompetenz und es ließe sich ohne die Community und viel Geld kein konkurrenzfähiges Produkt entwickeln. Somit ist Open Source hier ideal. Es ist somit nicht wirklich ein Geschäftsmodell ;-)

Der Pakt mit dem Teufel
Dies ist das letzte von mir vorgestellte Geschäftsmodell. Es ist das neuste und am wenigsten Erfolg versprechende Geschäftsmodell. Mehrere Linux Distributoren haben einen Deal mit einer konkurrierenden Firma geschlossen, der sie und zahlende Kunden vor Patentklagen schützen soll und dafür Geld erhalten. All diese Distributionen sind entweder unbedeutend oder haben in den letzten Jahren massiv User verloren. Die Deals dürften die Firmen kurzfristig retten, jedoch langfristig besteht keine Chance für sie. Anwender und freie Entwickler verlassen die Distributionen und wenden sich garantiert freien Distributionen zu. Dazu kommt, dass der diskriminierende Ausschluss per GPLv3 verboten ist. Die Distributionen verlieren beim Einsatz derartig lizensierter Software die Vorteile des Deals oder können die Software nicht einsezten. Langfristig werden sie dadurch keine aktuelle Software anbieten können und somit verschwinden.

Zusammenfassung
Open Source insgesammt stellt eine komplett neue wirtschaftliche Entwicklung dar. Manche würden es sicherlich als funktionierenden Kommunismus bezeichnen, wovon ich mich jedoch distanziere. Bei Open Source geht es um sehr viel Geld – es ist also ein kapitalistisches System. Bei Open Source erfolgt eine Trennung zwischen Anbieten einer Ware und deren Finanzierung. Ein Ansatz der sich wahrscheinlich auf viele weitere Wirtschaftsbereiche ausbreiten ließe. Das Prinzip Google basiert zum Beispiel darauf (Finanzierung über Werbung). Aber auch im Wissensbereich sehen wir zur Zeit eine klare Öffnung. Wissen ist kostenlos geworden und in Zukunft wird es den Brockhaus nur noch online geben, kostenfrei und quersubventioniert. Ich denke, dass sich das Modell der Öffnung weiter verbreiten wird und auch in anderen Bereichen zum Einsatz kommt. Warum nicht freie Baupläne, kostenlose Kaffeemaschinen, etc.? All dies ließe sich wohl quersubventionieren. Jedoch solange Open Source in kritischen Bereichen (Desktop) so eine Nischenstellung hat, werden wir es wohl kaum erleben, dass BWLer davon etwas mitbekommen. Jedoch wer weiß – vielleicht in 50 Jahren…

Was passiert eigentlich wenn man den Virtualisierer wechselt?

Ich habe mal vor einiger Zeit Windows Vista in einer VMWare virtuellen Maschine installiert. Da es aber für Gutsy kein einfaches Paket mehr gibt, habe ich auf VirtualBox gewechselt. Das ist ganz toll, denn VirtualBox kann VMWare Images lesen. Also neue Treiber installiert und alles läuft. Nun Vista findet das wohl trotzdem nicht so toll, denn jetzt gibt es folgende Meldung:
Vista

Ich muss mir jetzt mal den Spaß erlauben und bei Microsoft anrufen. Das eingeschränkte Arbeiten würde mich ja eigentlich nicht stören. VMs können eh kein Aero ;-) Aber das muss man einfach mal bringen: Ich hab nur den Virtualisierer ausgetauscht – an meiner physischen Hardware hab ich doch gar nichts geändert.