I was very interested in all of your ideas for a Grade Book, but was
surprized at how quickly the topic was dropped. In my opinion a grade book
should be of the heighest priority, mainly because there is a small number
of them out there and they are all very poor in features.
I have discussed this issue with Jeffery Elkner and we decided on writting
our own. I began brainstorming, and after having trouble with some design
issues he pointed me towards this mailing list. I read through several of
the emails, and found that people had already done some thinking on design
issues. So I would like to ask if we could come back to this topic and
decide on a final course of action.
The biggest problem that I have faced so far is deciding on a data
structure/format. I have decided to use an SQL Database, such as Gadfly
and/or PostgreSQL. The Grade Book program would see the database in an
objects oriented fashion, and these objects would have properties. This
would allow great customizability of the application, ie. if a teacher never
stores the student addresses she can delete the option, or if a teacher
wants to store the names of each students pets names she can add that field.
The following are some sample tables:
Student
-------
ID <- student reference id
Name (Data Item)
Address (id) -> reference to address table
Pet (id) -> reference to pet table
Address
--------
ID <- address reference id
Street (Data Item)
City (Data Item)
Pet
---
ID < pet reference id
Name (Data Item)
Type (Data Item)
So we can create a generic Python Class for any table, and it will figure
out what data to get for what purpose. The only thing needed for this is
maybe the database schema stored in an XML file or some other format so that
these objects are mapped out in some way. When this program is first started
it will have all of the common objects present such as student information,
assignment types, grade scales, etc., and through some sort of nifty
interface a teacher can add and delete fields for a student record, change
her grade scales, assignment types, etc, all these things will be described
in a seperate file. And then when a teacher clicks on a student to get more
information, the database schema defined for that specific
object/view/layout is read from the file and is used to construct queries on
the database. For the above example the teacher may define a student view to
display atudent name, address, and pet information.
structure file may say, describing the database, and views:
<student>
<id>
<name>
<address id>
<pet id>
</student>
<address>
<id>
<street>
<city>
</address>
<pet>
<id>
<name>
<type>
</pet>
<student view>
<name>
<address>
<pet>
</student view>
class Database:
def __self__(self, dbname):
# open connection
def getStudent(self, id):
# get database structure from a file and use it to
# create queries and get data from database
return studentdata
class Student(Database):
def __self__(self, id):
self.id = id
self.db = Database()
def showStudent(self):
student_view = self.db.getStudent(self.id)
#build GTK windows based on user specified layout for
#that that data, and put 'student_view' data in it
Displaying:
Lex Berezhny
5555 N. View Blvd.
Arlington
Joe
fish
Of course this is very primitive, but it should give you some idea. So I
would like to hear what people think of this and/or if they want me to clear
up some things. Thanks for your input.
- Lex Berezhny