Add seed_db project details.
diff --git a/GSoC2010Ideas.wiki b/GSoC2010Ideas.wiki
index a246bdf..238b176 100644
--- a/GSoC2010Ideas.wiki
+++ b/GSoC2010Ideas.wiki
@@ -164,17 +164,44 @@
 
 =Developer Tools=
 
-===Description===
-Seed_db improvements
-Easy setup for test cases
-Easy to extend and maintain
-Profiling and caching
+=== Description ===
+Everytime it comes to developer tools, most of developers are lazy or just overwhelemed by bug fixing and/or new exciting improvements that those tools are postponed forever. We make no exception! :) Although these tasks are normally not so exciting like bringing new end-user features, they are necessary for the whole application ecosystem, and to help developing ... new end-user features! Melange has two little cool modules (seed_db and seed_many) to seed the datastore, but they're quite outdated and doesn't respond to all our needs. Developing a fresh new and flexible module to seed the datastore to easen our work is going to be exciting as developing new end-user features. We would like an Ajaxy frontend and a strong bulletproof backend which communicates asynchronously with the frontend to make test cases easier to setup, which is easy to extend and mantain.
 
-===Skills===
+<Daniel please confirm your availability>
+Be aware that some code about a new data seeder has already been written by the awesome Daniel Hans, so you might want to talk also with him to have some hints on writing your application.
+</Daniel please confirm your availability>
 
-===Difficulty===
+==== Characteristics of the module ====
 
-===Mentors ===
+  * *Data seeder*: The data seeder should be a Python module which takes input from the frontend, does its duties and respond back to the frontend asynchronously (just to confirm that the Task has been activated). All seeded data should be distinguishable from user entered data. It should use Task Queue API for data seeding. Because it will be necessary to test and setup test cases also for statistics module, it could be quite complicated:
+    * Statistical distributions of data *: Having all students coming from USA and 1 year old is not the best thing when it comes to testing. Then we should need, for any model, a way to define a statistical distribution that the seeded data has to follow. Students ages, e.g., need to probably follow a normal distribution, not to forget that that distribution should be parametric: Summer of Code has no students under 18, but other events might accept different students age ranges. An exciting feature (although not required) would be to analyze past data of the same event in the datastore to gather probability densities. Same thing for students degree, country, other models details, etc.
+    * Easy to mantain *: Although standard melange models are not likely to change heavily in the future, no one knows... so we need to have a way to make the data seeder easy to mantain and extend. Maybe a clever use of Python reflection/introspection and (maybe?) some use of GAE metadata would make the module highly flexible.
+    * Dependency *: There's no way to create mentors if there are no organization seeded before. So, the seeder should be smart enough to tell the user that it should seed organizations first, or should give an option to automatically seed those organizations before seeding mentors. Also for this task, clever use of Python reflection and GAE metadata could give enough flexibility.
+    * Easy setup for test cases *: So, we would like to test the organization home page. But then a document for this organization must be created and associated with the organization home page. This is some kind of dependency, but it's not closely related to datastore, but to an abstract concept. Here it comes the flexibility for the seeder to accept some kind of configuration (probably guided by a JSON object that comes from the frontend) associated to test cases.
+    * Timeline *: Same thing for the timeline. If we want to test midterm surveys, we need to have the datastore seeded with everything that is necessary to go back and forth in the timeline.
+    * Options *: It should be possible to define some options for the seeder (e.g. number of entities to seed, number of org admins who are also mentors (fixed number or random)).
+    * GHOP/GSOC *: data should be seeded for multiple GSoC style programs instances, and also for GHOP style program instances (which are not seeded at all currently).
+  * *Ajaxy frontend*: Because of Task Queue API lack of a "reverse" communication, there is no possibility to respond back to the client when a task has finished: standard GET and POST requests are to be done. Still, there is no need to have a page reloading when doing this, as also standard GET and POST requests can be sent asynchronously. About the frontend we would like some ideas from students, depending on the backend architecture they propose. Furthermore, the Ajaxy frontend can be very simple: Ajaxy in this project doesn't mean extreme DOM manipulation, just asynchronous communication. We strongly prefer an awesome data seeder than a fancy frontend, as the frontend can be improved lately if the backend is well developed.
+  * Profiling *: TBD
+  * Caching *: TBD
+
+=== Skills ===
+
+  * Python
+  * Some Django, Javascript, Ajax, HTML/CSS skills, although not strictly required, are a plus
+  * Strong background in Statistic is a plus too
+
+=== Useful Links ===
+
+  * [http://code.google.com/appengine/docs/python/taskqueue/overview.html Task Queue API]
+
+=== Difficulty ===
+
+Moderate/Hard
+
+=== Mentors ===
+
+  * Mario Ferraro (Merio on #melange)
 
 ----