Hi all,
In past days I was interchanging some emails with Mr. Harrington
about a
proposal that I have for the Google Summer of Code relative to PyKata.
I post it
here for discussion.
Introduction
------------
About me: My name is Eliseo Ocampos, I'm from Paraguay and I'm
studying
Computer Science on the National University of Asunción [1]. My
programming background relies mostly on propietary software for the
National Center of Computing [2] (developing scripts, tools and APIs
for
a variety of systems that we have).
I consider the most significative way to give/share value with a
community
is to provide a mechanism or tool that helps members to learn an
hability.
Said that, I always aim to learn new ways to transmit my (very
limited)
knowledge, but if I could find a way that not only I could use but
anyone,
the multiplicator effect would be extended giving a lot more benefits.
In this case, the hability to learn a new languaje is always
exciting, but
the approach you use to learn it (or teach it) plays a major role in
the
success of this task.
PyKata gives you a pedagogical view most suitable for autodidacts
altough
this not necessarily has to be this way because people have different
ways
of learning something. What I will try to do in this project is to
give
several points of view to face the challenge to help to learn an
amazing
programming language _basically_ the way you want or you like the
most.
The Application Idea
--------------------
- General Modules to implement
. Profile & Stats for Users
While Using the application you should feel at home. This means
that the
profile has to provide you all you need to be comfortable while
learning
Python. Here we include the most common statistical data of your
progress,
recommended problems (by the application or by other users),
references to
relevant tutorials/blog posts and the like.
. Adventure-like leveling system
Here we want to visually impress the user, in a way he/she feel
the
process of learning Python an exciting trip. This leveling system
shouldn't be exact in a way that we "assign" a explicit score but
what
we'll want is to give him/her a kind of hierachy that resembles
the
habilities developed, asigned once overcome the several
"challenges"
provided.
. Categorization & Weigth of Problems
The atomic piece of learning is *one problem*. From it you can
learn a
very specific topic or a combination or various things. Here is were
we
desire the application help us to decide how well we can reward a
user. A
combination of several factors can assist us in this task, I
consider the
three most importants:
* Correct categorization of problems by: topics covered, level
of
previous knowledge required, estimated difficulty (here the
assignement of weight is necessary manual)
* Introduce (implicit) timing while resolving a problem: the
time spent
solving the problem could help the application to assign a
weigth to
the problem and decide the reward the user deserves, as well
as
relevant recommendations on topics covered. I consider the
implicit
timing important because we want the users feel as stressless
as
posible, allowing them to focus on the problem itself.
* Measure (Estimate?) code complexity: based on a solution
provided by
the author of the problem, the application can measure its
complexity
to put more or less weight to the problem. This also allow
the
application recommend other similar problems - inclusive it
can asign
"extra" reward if the provided solution's complexity is
beated ;)
- Let the fun begin - Pluggins in action
As I said, you can learn something in several ways and one of
them will
be the most comfortable to you (therefore probably the most
suitable).
PyKata can be restructured in a way that pluggins come into
action
providing special ways to learn Python concepts.
These Pluggins can be:
. Pair Programming Mini Environment: A place where you resolve a
problem
with another user, looking for achieve a new level or get some
special
reward.
. "Story Mode" challenges: Pre-established bulk of problems that
must be
resolved in groups (preferibly co-related but not necessarily
secuential).
. TutorView Plugin: Usefull for teachers or mentors who want to
monitor
a group of students, assigning special rewards for those who
finish the
"duties".
. PyKata Mini-Arena: A mini tournament could be organized
selecting some
problems and users to solve them & see who is the best!
Some of these pluggins should be available to users who has the
appropiate
level and others will be reserved only for administrators.
Underlying Structure
--------------------
The framework of choice for develop the "core" application will be
Django,
this is because my experience is vastly based in it. I am aware of
the
requeriments of easy maintaining for the future, that's why I pretend
trade-off that little hard learn of Django at begining for the
restructured
plugginable skeleton for PyKata. That adding the proper documentation
(wiki
pages, internal documentation) and several template for creating new
problems
_and_ new pluggins will also be provided, that way making easy for
future
developers of the project. I have previous experience in team work
(even
leading some small projects), so developing with other members of
community
wouldn't be difficult, in fact I think I'll really enjoy to do it in
an
open source environment.
I know the other candidate framework is web2py, altough I have no
experience
with it, I'll give it a try if community thinks this is the best
choice (in
fact I started to make some little projects with web2py in a way to
know it
better).
Tentative Cronogram
-------------------
April . 1st, 2nd and 3rd week: Discuss proposal detalis in PyWhip.
Getting
in touch with the actual code of PyKata.
April . 4th week: Begining with mockups and schematics, modeling
and
prototyping.
May . 1st, 2nd, 3rd and 4th week: Defining use cases. Establish
final
model to work with. Get the basic skeleton of the
application
structure.
June . 1st week: First Review and Documentation of the project,
rearrange
cronogram if needed, here also I allocate some days for
posible
contingencies.
June . 2n and 3rd week: Implementation and basic testing of
Profile
& Stats and Categorization & Weigth of Problems.
June . 4th week: Semester final Tests at College (estimated)
July . 1st and 2nd week: Implementation and basic testing of the
Leveling
System.
July . 3rd week: Second Review and Documentation of the project.
July . 4th week and,
August . 1st week: Implementation and basic testing of at least 2
(two)
plugins as a proof of concept of the design.
August . 2nd and 3rd week: Suggested 'pencils down' date by GSoC.
Take a week
to scrub code, write tests, improve documentation, etc.
August . 4th week: Finalizing the project (August 20).
This cronogram would be accomplished with 6 (six) hours per day,
including
weekends, giving 42 weekly hours to dedicate to the project, without
afecting
this to my normal activities.
[1]http://es.wikipedia.org/wiki/Universidad_Nacional_de_Asunción
[2]http://www.cnc.una.py
