Some notes about this plugin from commit-digest/2006-09-10:
When I first heard about Summer Of Code I thought about proposing a project called "Advanced Code Completion for KDevelop 3"(with full support for templates, comments, etc.), but when that didn't go down well with most of the KDevelop developers (since they were already focused on KDevelop 4), I just started implementing it. I spent a lot of time working on that until SOC started (and even quite some time since then), and you can see the result in the current KDevelop 3.4 SVN tree. I finished everything I planned and more.

Some of the features:
Intelligent resolution of types.
Support for templates like for example shared pointers.
Support for implicit template-instatiation
Nicer and more useful completion-list with items ordered in a useful way and indented by inheritance-depth, with popups that include comments and any other interesting information
Many improvements in the parser, for example all comments are extracted and used in any possible way, macros are dealt with correctly, Enums are handled in a more useful way, and much more
A powerful navigation-menu: Click any item within a function and see it's real type, a trace of all typedefs on the way to that type, information on all involved typedefs, classes, variables, functions, etc., and the same as a submenu for all involved template-parameters, argument-types, base-classes, etc.
Improved jump-to-menus and navigation-bar.
Highlighting of function-names in the navigation-bar and class-tree.
And countless other major improvements in code-completion and navigation.. see the feature list of the beta releases or the commit log to see all of them.

KDevelop 3 is doing well feature-wise, but currently lacks developers since the focus already is on KDevelop 4, but it'll take a long time until that is really usable, so I hereby encourage anyone interested to start using the SVN version of KDevelop 3.4 and hunt down a few bugs, to make sure that a stable version can be released soon.

Collaboration through the internet is fundamental to most open-source-software. Almost any open- and even closed-source-software might profit from better collaboration-possibilities. If you work for a project that has a collaboration-server, you can directly ask other developers working on the same project for very specific help, patches can be reviewed very quickly, and discussion can instantly take place within the documents themselves. File Collaboration may also be useful for discussion of new ideas, teaching, for friends less experienced in programming requesting help (Or am I the only one who is asked how to program something through ICQ again and again?), and simply because it's cool ;)

So I took the basic Idea for the Summer Of Code project "KDevelop Teamwork" from the Wiki where someone proposed it, and developed it using my own Ideas, trying to add some of the teamwork features I always missed in any IDE I ever used. :)

Generally it consists of four parts:
Client/Server Architecture
I created a multi-threaded library for networking, including client/server- and user-management, and a standalone server not dependent on Qt which can be run on any webserver and administrated using the console.

File Collaboration
An arbitrary count of developers can collaboratively edit a dynamic set of files, and the edited documents can be dynamically transformed (for example chosen changes made by exactly one user could be undone, which will allow single-user undo, redo, etc.)

Conversation
All users connected to any of the connected servers, as well as the servers themselves (in the case they are not standalone) can be contacted by using instant messages, collaboration-requests, patch-requests, in-document messages, etc.

The most interesting message for conversation is the in-document message: It can reference a position or piece of text within any document, and the receiver of the message automatically jumps to that document and highlights the referenced piece of text as the message is selected, and pops up a chat-window within the document itself at the found position, where other messages of the same thread may be selected and discussion can take place.

Any answers written into the chat will automatically reference the currently selected text. Referencing is simply done by marking a piece of text before sending a message, and the reference-position is being found by a fuzzy algorithm I developed which tries to find the correct place even within totally different documents (and is pretty successful at doing so).

Patch Management
Every user can manage a set of patches (or other file types) for each project. They can either be files or dynamic patches which are automatically retrieved from commands on request (for example "svn diff"). Patches can be easily shared directly through the developer-list, using different access-levels.

A modified version of Kompare's diff3-library is used to get information from patches. Using that the patch-manager can automatically highlight all changes made by an applied patch within all documents, and allows you to easily browse through those positions so you can review the patch within the correct context and directly discuss about it using in-document messages.

They can be applied/reverted to the local tree using single buttons, and for diff-files it is possible to automatically determine whether the patch is already applied or not. If problems arise within the patching process they can be dealt with using an embedded console in the patch-management-window.
It is important that all those features are well integrated: For example you can store the results of a file-collaboration-session as a patch into your local patches-list, and thereby share it with other developers and easily revert it at any time, and you can use in-document messages directly within the temporary file-collaboration files.

To store all the project-specific data (like patches), a ".teamwork" subfolder is created within the project directory.

I encountered many problems during development. Apart from one harddisk crash, the most annoying problem was the very unstable and (in the begginning) difficult to compile kdelibs/qt-copy/qdbus/kdesupport etc. combination, which again and again cost me days and hours just to get it working.

The most challenging part was the file-collaboration. Getting a simple form of collaborative editing to work was quite fast, but making the document-transformation work correctly in all test-cases really took some time, and I had to finish it after the deadline without stress (luckily I didn't mention anything like it in my application ;)). The trick was writing everything down and trying to solve it mathematically as I learnt at university, unfortunately I got that idea after days of unsuccessful hacking and trying - well... you live and learn :)

I was able to finish nearly everything I planned until the deadline, but unfortunately I missed the week I planned in my application for "debug, make it perfect", so that work is missing, and it shows :) Most of the work I did after the Summer Of Code ended was in other, more important parts (finishing the text-transformation algorithm, or fixing file-collaboration which stopped working after a kdelibs-update), but it is work I'll surely do. Then there's one other big problem, the executable-size when the executable is built with debug-information. During my work on this project I fell in love with templates and meta-programming, but I think the main reason is my use of boost serialization, I'll still have to work on that. Then of course i'll need some nice icons. :)

  Now that the Summer Of Code has concluded, the first thing I will do is working intensively for the institute of my university that paid me the whole year, and that I neglected since March because of my work for KDevelop 3 Code Completion and then the Summer Of Code. Of course, I won't forget KDevelop and KDE in general, since I like the Open-Source Idea a lot. I started working on Open-Source Software before I started the Summer Of Code, and I won't stop it now that it's over :) I'll keep maintaining the teamwork-module (and of course finish it), I'll keep caring about KDevelop, and maybe I'll start a project to make KDE more Tablet PC friendly if I can find the time for it. 
