On Mon, Aug 31, 2009 at 05:20:23PM -0700, Christopher Lee wrote:
-> I want to outline some suggestions for the 0.8 tutorials, to invite  
-> your feedback.

Briefly,

I think tutorials should be

  a) correct
  b) simple and straightforward
  c) executable
  d) prescriptive for simple examples
  e) complete and comprehensive

in that order!

-> - Titus' alignment tutorial only covers pairwiseMode.  I think we may  
-> want to add both a basic multiple sequence alignment example, and an  
-> example making use of the NLMSA.add_aligned_intervals() method.

Yes, but I would rather not try to do this on short notice.  Add an
issue for 0.8.1, mebbe?

-> - we need to update this tutorial to reflect the new reporting of self- 
-> matches from pairwise NLMSA / blast.

Good point, will do.

-> - Titus, will the "scalability" tutorial replace the existing  
-> annotation.rst tutorial, or will it be an *additional* tutorial?  The  
-> code examples you posted seem to assume that the reader already knows  
-> all about Pygr annotation concepts, i.e. they already finished the  
-> existing annotation.rst tutorial...

Do you mean this?

http://lyorn.idyll.org/~t/transfer/doc_alignments/tutorials/annotation.html

I think the new (still unfinished) tutorial could replace about half of
the old one, and the other half could be rewritten into advanced
discussion at the end of the new tutorial.  The existing tutorial
doesn't really "tutor", it gives a list of features and shows some very
terse example code that doesn't execute in a standalone way.

-> - in the scalability tutorial, we may want to showcase SQLTable with  
-> sqlite before showing the shelve variants.  We want to encourage users  
-> to work with sqlite in preference to shelve (which newer versions of  
-> Python are not supporting solidly, due to the removal of bsddb from  
-> the Python standard library).

I chose to order things the way I did because 'shelve' is a standard
Python data storage technique (it's a dictionary! that magically
persists!), while SQL is considerably more advanced.  I think sometimes
you forget how much you know ;)

-> - the sqlite code example can be made much simpler by using  
-> SQLiteServerInfo to connect to the database and SQLTable to create the  
-> table and save data to it.  If Titus can push this tutorial to github,  
-> I can add appropriate modifications...

Done, would appreciate the tips.

-> - I'm wondering whether we need a "database tutorial" that illustrates  
-> Pygr's recommended ways to create and use data containers (via SQL,  
-> shelve etc.).  Currently, there is some material hidden at the back of  
-> the worldbase tutorial, but I suspect nobody would know to look there  
-> for it.  I could extract that material and add more, to create one  
-> tutorial that would cover all Pygr's "container classes".  In the  
-> past, the docs tended to assume that a user already had a database  
-> stored in SQL or a shelve, and thus only showed how to work with  
-> *existing* databases.  So I think we need new tutorial material  
-> showing how to create databases, and to highlight the "Pygr way" of  
-> doing this.
-> 
-> Do people think it's a good idea to pull the database issues out as a  
-> separate tutorial?

+1

-> - I must confess I remain uncertain as to what exactly people want in  
-> the "gene build tutorial", partly because this overlaps the annotation  
-> tutorial (show how to store annotations for genes and exons), and  
-> partly because I'm probably the worst person in the world to  
-> understand "what confuses users about Pygr".  Unless other people can  
-> give me some guidance, this tutorial will simply be:
->    * based on the existing annotation tutorial, introducing Pygr  
-> annotation concepts;
->    * add more code examples for actually *creating* new annotation  
-> databases to store genes and exons (the existing tutorial assumes the  
-> slice info is already stored in a db).
->    * incorporate the GFF loading example submitted recently on this  
-> discussion group.

+1.  I really don't understand how to use the graphing relations to set
up exon structures and I would really appreciate some straightforward
code that Just Works, from A to Z.

Then, as the self-appointed tutorial-meister, I will be happy to take
your functioning code, grok it, and write long, discursive discussion
around it (and then claim credit ;).

cheers,
--titus
-- 
C. Titus Brown, [email protected]

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"pygr-dev" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to 
[email protected]
For more options, visit this group at 
http://groups.google.com/group/pygr-dev?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to