User:Zero Linden/Office Hours/2008 June 19

From Second Life Wiki
Jump to: navigation, search
  • [8:33] Morgaine Dinova: Is there an agenda for today?
  • [8:33] Enus Linden: sure thing sic.
  • [8:33] Morgaine Dinova: Hi Sai
  • [8:34] Enus Linden: Morgaine, tess was *gonna* run the show, but she was having power issues and has crapped out
  • [8:34] Morgaine Dinova: Ouchies
  • [8:34] Saijanai Kuhn: hello everybody
  • [8:34] Morgaine Dinova: Hi Rex
  • [8:34] Enus Linden: so, we can talk test harness to the degree that we're willing
  • [8:34] Locklainn Linden: hi rex
  • [8:34] Saijanai Kuhn: hiii...
  • [8:34] Enus Linden: i know of no other topics
  • [8:35] Enus Linden: any topics you'd like to suggest, lemme know
  • [8:35] Enus Linden: hamilton is gracing us with his presence as well... hi hamilton
  • [8:35] Morgaine Dinova: Test harness is always a good topic, seeing as so much new stuff will need testing
  • [8:36] Morgaine Dinova: Hi Hamilton
  • [8:36] Saijanai Kuhn: hello hamilton
  • [8:36] Hamilton Linden: Hi guys
  • [8:36] Baron Nowhere: I saw on the viewer roadmap a "browser based" hud [(http://wiki.secondlife.com/wiki/Viewer_Roadmap)] and was interested in hearing how that fit into the architecture, and if that was different from media on prims, and maybe a primer on how users would interact with the hud
  • [8:37] Enus Linden: I don't know anything about that effort Baron, willing to poke in internal tools for a sec to see...
  • [8:37] Enus Linden: we can wait a few more to get rolling for real though, let folks wander in
  • [8:38] Enus Linden: might as well get started...
  • [8:38] Hamilton Linden: Guys, next Thursday I'll be hosting this meeting and getting feedback on AWG interop testing with OpenSim and our roadmap for interop
  • [8:38] Morgaine Dinova: Excellent
  • [8:38] Saijanai Kuhn: so the topic or tpoics for today are...?
  • [8:38] Hamilton Linden: so if you have interest or might know someone who does with doing interop testing with our AgentDomain be sure to attend
  • [8:38] Enus Linden: Hi everyone, I'll be your proxy tess for now, who is actually a proxy for zero, who is taking a much deserved break from us all
  • [8:38] Enus Linden: topics: test harness
  • [8:39] Enus Linden: and anything else that comes up
  • [8:39] Enus Linden: heya rex
  • [8:39] Infinity Linden: topics: and test cases
  • [8:39] Morgaine Dinova: Wow, double proxy ;-)
  • [8:39] Enus Linden: oh yes please
  • [8:39] Enus Linden: crap gesture again
  • [8:39] Locklainn Linden: haha
  • [8:39] Enus Linden: infin*ty change your name lol
  • [8:39] Tess Linden: hey guys, im back
  • [8:39] Saijanai Kuhn: wb tess
  • [8:39] Sicarius Fegte: welcome back
  • [8:40] Morgaine Dinova: Inifnity must be the other side of Zero ;-)
  • [8:40] Enus Linden: so test harness: refers to the pyogp work that AWG and LL are undertaking as a joint effort to test the OGP documentation and implementations
  • [8:40] Enus Linden: lol morgaine
  • [8:40] Enus Linden: [1]
  • [8:40] Infinity Linden: we like to say "somewhere between infinity and zero we'll find a solutiin:
  • [8:40] Morgaine Dinova: lol
  • [8:40] Infinity Linden: except we type better in the office
  • [8:41] Tess Linden: today I invited Enus to talk about the test harnes and organizing the test harnes to test each ccomponent of the client , agent domain, and region domain
  • [8:41] Enus Linden: the intent is to build a python based client library and test harness that can be used to interact with the various domains that are being defined in the Open Grid Protocol
  • [8:42] Enus Linden: [2]
  • [8:42] Saijanai Kuhn: hi enus
  • [8:42] Enus Linden: we've gotten started to a degree on the code base and test framework, but it's totally a rough draft.
  • [8:43] Enus Linden: there is a public svn with what's been done to date, but there is first a decision to be made about library framework
  • [8:43] Enus Linden: i've stubbed out a simple python class structure here: [3]
  • [8:43] Gareth Ellison: zero on holiday this time?
  • [8:44] Morgaine Dinova: Yep Gareth, Tess has the chair, and Enus is on the throne
  • [8:44] Morgaine Dinova: Looks like Sai's in trouble, yoyoing
  • [8:44] Enus Linden: Tao akashi has stubbed out a different implementation, that favors component based python using zca (zope component architecture) here: [4]
  • [8:44] Gareth Ellison: plain python is vastly preferable: eliminate the deps
  • [8:44] Enus Linden: I dearly hope to have Tao convince us collectively that zca is 1. better and 2. not too challenging to implement
  • [8:44] Infinity Linden: good input, Gareth
  • [8:45] Enus Linden: i agree gareth, but, if zca enables easy plugins
  • [8:45] Enus Linden: and can be explained in a simple wiki
  • [8:45] Enus Linden: i think it's worth running with it
  • [8:45] Gareth Ellison: i'm just pondering the mess of deps for mulib
  • [8:46] Enus Linden: Tao is going to attempt to build out a working login model this weekendf
  • [8:46] Gareth Ellison: since it's highly irritating setting up mulib on a new box
  • [8:46] Enus Linden: I hope to compare my simple python vs tao's zca early next week and move forward with one or the other
  • [8:46] Dahlia Trimble: is Tao agtive on #pyogp?
  • [8:46] Morgaine Dinova: Would it require only a small part of Zope? Being dependent on the whole huge thing doesn't sound like a good idea.
  • [8:46] Gareth Ellison: if truth be told, that's why i personally don't use mulib and use web.py and some weird hacks
  • [8:46] Dahlia Trimble: *active
  • [8:47] Tess Linden: does anyone else have any lean one way or the other ?
  • [8:47] Infinity Linden: gareth... do you have a list of the "weird hax"?
  • [8:47] Enus Linden: taos on the way
  • [8:47] Gareth Ellison: i have my custom little BaseHTTPServer-based httpd
  • [8:47] Infinity Linden: Personally I like having fewer dependencies
  • [8:47] Gareth Ellison: which i then have a wrapper round to integrate with web.py
  • [8:47] Gareth Ellison: don't want a repeat of that if possible
  • [8:48] Mrs Sterling: lmao
  • [8:48] Mrs Sterling: i'm stuck
  • [8:48] Infinity Linden: but I don't really know too much about ZCA, so it's hard for me to say it's too much
  • [8:48] Morgaine Dinova: There is one huge problem with using Zope, beyond the mere dependencies one: it means that this will never be portable to anything other than Python.
  • [8:48] Gareth Ellison: 3 points to morgaine
  • [8:48] Tao Takashi: Hi
  • [8:48] Gareth Ellison: tao - lecture us on ZCA
  • [8:48] Sumax Mighty: Greetings eveyrone.
  • [8:48] Enus Linden: checking
  • [8:49] Tao Takashi: I forgot my slides ;-)
  • [8:49] Enus Linden: portablity is a good point: i'd envision a good buildout of the libraries, and then applying them in many different environments
  • [8:49] Tao Takashi: but I can give you the basic idea
  • [8:49] Enus Linden: but python is at the core use
  • [8:49] Gareth Ellison: technically speaking portability of the code isn't that important
  • [8:49] Enus Linden: yes*
  • [8:49] Infinity Linden: there's no reason you can't take the OGP spec and implement tests in Smalltalk, Java ,Javascript or even Visual Basic
  • [8:49] Saijanai Kuhn: hi tao, hi sumax
  • [8:49] Gareth Ellison: if the protocol can be implemented in other languages: yay
  • [8:49] Gareth Ellison: i've been working on porting mudata (my mulib extension that adds MySQL representation to mulib)
  • [8:49] Tao Takashi: the protocol is supposed to be implemented in other langs ;-)
  • [8:49] Gareth Ellison: i.e don't do the OGS thing and use .NET remoting......
  • [8:49] Enus Linden: so Tao: plain python vs zca
  • [8:49] Infinity Linden: well.... we are talking about the python implementation..
  • [8:50] Enus Linden: advantages, disadvantages
  • [8:50] Enus Linden:  ?
  • [8:50] Enus Linden: (and thanks for popping in)
  • [8:50] Tao Takashi: this gives you the advantage of independance of the actual implementation
  • [8:50] Infinity Linden: I would perfer we be able to write individual test cases such that they work in both "plain" and "ZCA" variants
  • [8:50] Morgaine Dinova: Infinity: a test harness is typically the start and the reference for many projects that use the thing being tested. Porting to a different modern language is easy, but if the test harness relies on a big infrastructure system like Zope then changing language may not be so easy.
  • [8:50] Tess Linden: hi Tao :)
  • [8:50] Tao Takashi: maybe it's better when I come with some examples ;-)
  • [8:50] Bartholomew Kleiber: Hi Tao and all
  • [8:51] Morgaine Dinova: And the protocol is of course language-independent, not Python-specific.
  • [8:51] Infinity Linden: Yeah... I see what you're saying... ew're actually hoping people will use our test harness as example code
  • [8:51] Saijanai Kuhn: hi bartholomew
  • [8:51] Tao Takashi: so for instance you can have an interface calles IAgent and a class which implements it
  • [8:51] Tao Takashi: so, the basic idea of the ZCA is that you define interfaces for your components
  • [8:52] Infinity Linden: but ZCA vs. "regular" python won't make anyone more or less interested in other implementeations
  • [8:52] Infinity Linden: (okay... just pretend I can type this morning)
  • [8:52] Tao Takashi: I am just looking for the stub example
  • [8:53] Morgaine Dinova: Poor Sai. His computer seems to be possessed.
  • [8:53] Enus Linden: tao, can we look at what you've stubbed out for examples (even if they are incomplete?)
  • [8:53] Tao Takashi: bascially the class implementing this interface simply needs to add an implements(IAgent)
  • [8:53] Gareth Ellison: tao, about ZCA
  • [8:53] Gareth Ellison: can't you do something like that in any OOP language?
  • [8:53] Gareth Ellison: just define a base class or an interface
  • [8:53] Tao Takashi: which you can see here: [5]
  • [8:53] Tao Takashi: yes, we had that in Zope2
  • [8:53] Tao Takashi: and ended up with a lot of mixed in base classes
  • [8:54] Tao Takashi: nobody knew anymore where what came from
  • [8:54] Saijanai Kuhn: a uml class diagram might be quit usefull:)
  • [8:54] Infinity Linden: in general, each OO language that supports reflection has something referred to as a "component model"
  • [8:54] Infinity Linden: well.. unless ZCA'c componentness is only expressable in python
  • [8:54] Bartholomew Kleiber: seh Dich
  • [8:54] Infinity Linden: if we were masochistic, we could even use the CORBA Component Model
  • [8:54] Tao Takashi: so here is an example of an interface definition: [6]
  • [8:54] Tao Takashi: so one example would be that you need a size method for a document
  • [8:54] Tao Takashi: but the Document class does not provide it
  • [8:54] Gareth Ellison: if you just define one base class for each interface, what's wrong with doing that? it lets you plug in other implementations easily
  • [8:55] Gareth Ellison: in fact, technically you don't need any base class at all in python
  • [8:55] Gareth Ellison: and override methods
  • [8:55] Gareth Ellison: duck typing
  • [8:55] Tao Takashi: but if it implements IDocument which might contain a getContent() method then some function can use getContent() to compute the size
  • [8:55] Enus Linden: here's my first pass an at agent base class: [7]
  • [8:55] Tao Takashi: so in this case you can "adapt" the document to an adapter which provides getSize()
  • [8:55] Locklainn Linden: so it seems ZCA is just used to allow interfaces, but python allows it implicitly?
  • [8:55] Enus Linden: I'm not yet seeing the advantage of zca implementations
  • [8:55] Enus Linden: I'm not yet seeing the advantage of zca implementations
  • [8:55] Tao Takashi: well, you can do it more aspect oriented
  • [8:56] Tao Takashi: you need the getSize() method and then you adapt the object to the ISize interface like this: ISize(document)
  • [8:56] Gareth Ellison: lesser languages have static typing
  • [8:56] Gareth Ellison: you need to pass function X an object that implements ISomeInterface
  • [8:56] Infinity Linden: keep in mind my secret shame is a love of JavaScript
  • [8:56] Gareth Ellison: python you don't need to bother with ISomeInterface
  • [8:56] Gareth Ellison: excuse the lag
  • [8:57] Morgaine Dinova: I don't think we want a language war about this. But I can't see the major plus yet that would overcome the disadvantages of the large depedency.
  • [8:58] Tao Takashi: what large dependancy?
  • [8:58] Morgaine Dinova: Zope
  • [8:58] Tao Takashi: it's not Zope
  • [8:58] Tao Takashi: it's not Zope
  • [8:58] Tao Takashi: it's not Zope
  • [8:58] Tao Takashi: it's a small part of Zope which was factored out
  • [8:58] Morgaine Dinova: Ah, good info at last :-)
  • [8:58] Locklainn Linden: haha
  • [8:58] Gareth Ellison: just reading over the code in that repo and there's stupidly large levels of nested directory structures too, quite ugly
  • [8:58] Tao Takashi: I don't want to build this on Zope ;-)
  • [8:58] Gareth Ellison: really you should only need a few modules:
  • [8:58] Gareth Ellison: 1 common with misc utils and stuff
  • [8:59] Gareth Ellison: and 1 for agent domain
  • [8:59] Tao Takashi: I like it because it allows of separate packages which can be developed independant
  • [8:59] Gareth Ellison: 1 for region domain
  • [8:59] Gareth Ellison: etc
  • [8:59] Tao Takashi: even on different repos and still can share the same namespace
  • [8:59] Saijanai Kuhn: if there is a uml class diagram, there is no need for war. anybody can implemented in whatever language they like. although it isn't that easy to make the diagram:)
  • [8:59] Infinity Linden: Rex +1
  • [8:59] Saijanai Kuhn: [8]
  • [8:59] Tao Takashi: Gareth: That's namespaces used by eggs
  • [8:59] Locklainn Linden: right, but if I'm right then the point is so that we don't all do the same work?
  • [8:59] Tao Takashi: so as I see much opposition of using ZCA I am not sure how we go from here
  • [9:00] Tao Takashi: I don't really want to miss this feature ;-)
  • [9:00] Morgaine Dinova: Hmmm, no ZCA in Portage yet. How long ago was it factored out of Zope?
  • [9:01] Tao Takashi: zope.interface and zope.component are the eggs
  • [9:01] Tao Takashi: and could more easily be exchanged
  • [9:01] Enus Linden: what do we lose by omitting zca?
  • [9:01] Tao Takashi: [9]
  • [9:01] Tao Takashi: flexibility
  • [9:01] Tao Takashi: and independance of parts
  • [9:01] Tao Takashi: so I cannot simply replace the agent implementation of the lib because you hardwired import pyogp.lib.agent
  • [9:02] Morgaine Dinova: Oh, it's still bundled in with Zope? So we *do* have to install all of Zope before we can use ZCA?
  • [9:02] Tao Takashi: no, it's a separate egg
  • [9:02] Saijanai Kuhn: ZCA seems to be Python's anwer to what is built into Smalltalk and other pure OOP langauges
  • [9:02] Tao Takashi: but in the zope namespace to show where it's coming from
  • [9:02] Infinity Linden: Smalltalk +1
  • [9:03] Tao Takashi: I use ZCA regularly also without Zope
  • [9:03] Morgaine Dinova: Well, it's not in Portage, whereas Zope is. So I guess the Gentoo community isn't happy with ZCA as a separate component.
  • [9:03] Tao Takashi: well, I tend to not use packages but use easy_install and buildouts to retrieve packages
  • [9:03] Tao Takashi: and eggs is the python package format
  • [9:04] Tao Takashi: they get installed locally in the buildout sandbox which makes this independant from the rest of the system
  • [9:04] Tao Takashi: so I can also use different versions of eggs in different sandboxes that way
  • [9:04] Enus Linden: is starting to see how zca is useful, but, is the component aspect such a big advantage in this effort that the percieved barrier of a steep learning curve a hinderance to adoption/contribution, etc?
  • [9:04] Tao Takashi: I think basic ZCA is not really that hard. Maybe some good example is missing
  • [9:05] Tao Takashi: but I also think that maybe the test harness does not really need to use it while I think the lib could benefit from it
  • [9:05] Tess Linden: wel.. everyone still has to learn the interfaces of our home grown system
  • [9:05] Morgaine Dinova: True, Tess
  • [9:05] Tess Linden: can we use an example to compare?
  • [9:05] Tao Takashi: so who here actually would work on a python based test harness
  • [9:05] Tao Takashi:  ?
  • [9:05] Infinity Linden: would a PyUnit test on ZCA be radically different than on "stock python"?
  • [9:05] Tao Takashi: Infinity: nope
  • [9:05] Enus Linden: would be the same tbh
  • [9:05] Enus Linden: grrr
  • [9:05] Locklainn Linden: I'm going to be working on it all summer
  • [9:05] Enus Linden: disables that gesture for good
  • [9:06] Morgaine Dinova: chuckles @ gesture
  • [9:06] Tao Takashi: ZCA is also really not radically different from stock python
  • [9:06] Saijanai Kuhn: The ZCA defines a 'component' simply as an object that explicitly declares that it provides one or more interfaces. For example:
  • [9:06] Infinity Linden: totally missed teh gesture... probably a good thing
  • [9:06] Tess Linden: Tao: I would write test
  • [9:06] Tao Takashi: it just adds the interface concept and you have to register which class implements which interface and you retrieve those classes by their interface name instead of the class name
  • [9:06] Tess Linden: tests*
  • [9:06] Tao Takashi: then somebody can override this
  • [9:06] Tao Takashi: it also makes it easier to create smaller modules instead of big classes
  • [9:06] Tao Takashi: which IMHO is a big plus also for testing and clarity
  • [9:07] Infinity Linden: maybe the answer is to write a "stock" pyunit test
  • [9:07] Saijanai Kuhn: like I said, its Python's answer to what pure oop does automatically
  • [9:07] Infinity Linden: then have Tao "port" it to ZCA
  • [9:07] Enus Linden: true tao, we want to be able to test at minute levels
  • [9:07] Infinity Linden: in the meantime Sai and I will be writing SUnit tests
  • [9:07] Tao Takashi: well, that was one idea. I look on what you come up with and port it to use ZCA ;-)
  • [9:08] Tao Takashi: because you might have a better idea on what to test actually and how ;_)
  • [9:08] Tao Takashi: as you know the system
  • [9:08] Infinity Linden: *actully I jest , I don't think I;ll be able to write teh SUnit tests unless we know we have the pyunit tests working
  • [9:08] Morgaine Dinova: Indeed --- nobody said there needs to be only one single test harness! :-)))
  • [9:08] Tao Takashi: another question is whether to use buildout or not
  • [9:08] Infinity Linden: but someone made a comment earlier about how test harneses are used by developers in an attempt to grok the api
  • [9:08] Tao Takashi: there are nice recipes which collect all the test in all modules and let you run them automatically
  • [9:09] Infinity Linden: I've definitely seen that effect too
  • [9:09] Saijanai Kuhn: and come to think of it, wouldn't it be possible to write a ZCA wrapper around a C or C++ module?
  • [9:09] Tess Linden: morgaine: we'd like to concentrate our efforts so we can get more coverage
  • [9:09] Infinity Linden: and while we don't want to put all our eggs in one basket
  • [9:09] Tao Takashi: in doctest style so you can also explain what's happening a bit more
  • [9:09] Saijanai Kuhn: winces at python reference
  • [9:09] Infinity Linden: if ew concentrate.. yup... what Tess said
  • [9:09] Tao Takashi: How actually do you want to use the lib in other languages then?
  • [9:09] Tao Takashi: be it with or without ZCA?
  • [9:10] Tao Takashi: or are we speaking about porting it?
  • [9:10] Morgaine Dinova: Sai: no language *really* has a component registration mechanism built in. They all create one by layering on top of base functionality.
  • [9:10] Tao Takashi: and what's the purpose of the test harness? to test components in whatever language to check if they work?
  • [9:10] Saijanai Kuhn: hmmm, well, but some have more basic base functionality than others, so the architecture is a tad thinner
  • [9:11] Tao Takashi: well, the ZCA of course is also on top of plain python
  • [9:11] Tao Takashi: but it gives you a central registry
  • [9:11] Infinity Linden: Tao.. our purpose for a test harness is mostly to "just run the tests"
  • [9:11] Enus Linden: the purpose of this test harness is to test the OGP implementation wherever it lives, using the python libs to interact with said implementations
  • [9:11] Infinity Linden: to ensure that the protocol is working
  • [9:11] Morgaine Dinova: Perhaps someone can show us a use case of how this helps in a test harness?
  • [9:11] Infinity Linden: and to ensure that oru impelemntation is working
  • [9:11] Morgaine Dinova: Tao: does ZCA provide a C/C++-level API as well? So things have speed or timing requirements.
  • [9:12] Tao Takashi: ok. But then I guess the lib would also have tests of their own to check maybe their inner functionality
  • [9:12] Enus Linden: yes tao
  • [9:12] Morgaine Dinova: Some* things (typo)
  • [9:12] Saijanai Kuhn: Morgaine, the only issue I see with ZCA is whether or not there's a problem with using other languages which lack a component registration facility. It' what many languages have as part of hte language definition, as far as I can tell
  • [9:12] Tao Takashi: Morgaine: not that I know of although I am not sure if the central part of it isn#t written in C for performance reasons
  • [9:12] Tao Takashi: but you can use C++/C extensions normally
  • [9:13] Tao Takashi: well, I would also write tests for the lib
  • [9:13] Tao Takashi: so the test harness IMHO does not really need some component registry as I think of it mainly as a collection of tests
  • [9:13] Tao Takashi: which should be not too complex
  • [9:13] Enus Linden: I'd like to revisit this tuesday at the AWGroupies meeting, and hope to be able to choose the zca/no zca approach we want to move forward with.
  • [9:13] Tao Takashi: if they use the lib and the lib uses ZCA then of course they might adjust how they use the lib in writing things a little different
  • [9:14] Saijanai Kuhn: is the test harness for testing both clients and servers?
  • [9:14] Saijanai Kuhn: there's our irc
  • [9:14] Enus Linden: yes tao
  • [9:14] Infinity Linden: I think where the components come in is if we want to take our libs we're using to enable tests and make them available as more general "client language bindings" for the OGP spec
  • [9:14] Tao Takashi: as said, I would like to work something out using buildout, eggs and ZCA (the former 2 are already there in some form) which is working
  • [9:14] Tao Takashi: and maybe show some examples
  • [9:15] Infinity Linden: Enus... we've always said we should work under the basis of "consensus and working code."
  • [9:15] Dahlia Trimble: how hard is it to switch from zca to python or back once coding has started?
  • [9:15] Tao Takashi: as said, I would rather not work without it as I think it makes components more modular
  • [9:15] Morgaine Dinova: It should definitely be both server and client --- remember that some of the tests will involve looking at both sides to see test results.
  • [9:15] Saijanai Kuhn: ZCA os kist a cp,[pmemt regostratopm fra,ewprl. as far as O cam te;;
  • [9:15] Saijanai Kuhn: or something like that
  • [9:15] Tao Takashi: btw, there also is no full ZCA and no ZCA, there are also levels inbetween ;-)
  • [9:15] Tao Takashi: so it depends on how many interfaces/hooks you provide
  • [9:15] Infinity Linden: wow... Sai... I actually was able to parse that first line there
  • [9:16] Enus Linden: yes tao, i see the advantage of modularity... without it, refactoring is one's only choice to adding components
  • [9:16] Dahlia Trimble: I thought python had some kind of component use model already
  • [9:16] Enus Linden: What's the best way to decide as a group with direction to take?
  • [9:16] Tao Takashi: usually you can also move a project later to ZCA but it's some work to get it right then and involves a lot of refactoring to make sense. We are going through this with Plone right now
  • [9:16] Morgaine Dinova: Infinity: lucky you. My parse triggered the Halting Problem ;-)
  • [9:16] Enus Linden: *rexz
  • [9:16] Infinity Linden: I'm an old FORTH programmer... so I recover well from noise in the line
  • [9:17] Enus Linden: also tao, I'm hoping we can build in OGP oriented libs and 'legacy' aka libs that work against the current protocol
  • [9:17] Morgaine Dinova: chuckles
  • [9:17] Tao Takashi: well, Python has classes, modules and functions
  • [9:17] Enus Linden: in pyogp itself...
  • [9:17] Infinity Linden: but getting back to the task at hand.. I think a lot of us don't have ZCA experience...
  • [9:17] Saijanai Kuhn: ZCA is just a component registration framework
  • [9:17] Infinity Linden: many of us seem to think the idea of modularity / componentization is a good one
  • [9:17] Tao Takashi: Enus: I am all for it as long as somebody shows me how to do the UDP dance (but there's an example now) and how to decipher the messages ;-)
  • [9:17] Tao Takashi: I think it lacks examples right now to show the benefits
  • [9:18] Infinity Linden: and Tao tells us if we get the "stock python" wrong, it'll be a refactoring effort to get it right
  • [9:18] Tao Takashi: so I will try to come up with something and maybe convert the login stuff to some more componentized version
  • [9:18] Enus Linden: revisit Tuesday morning?
  • [9:18] Infinity Linden: Perhaps we should rwite some tests in "stock python" and then componentize them
  • [9:18] Tao Takashi: well, there really is not too much difference between ZCA and stock python
  • [9:18] Morgaine Dinova: Sounds good
  • [9:18] Tao Takashi: it's hard to explain it here right now quickly
  • [9:18] Tao Takashi: Infinity: as said, I am more thinking about the lib
  • [9:19] Tao Takashi: not the tests itself
  • [9:19] Enus Linden: lib could use zca, test don't care
  • [9:19] Tao Takashi: so that's why I propose to work on the login code which is there right now
  • [9:19] Tao Takashi: so I will try to work on that at the weekend
  • [9:19] Infinity Linden: oh oh... yup... I like the idea of componentizing the libs
  • [9:19] Tao Takashi: so tuesday should be ok
  • [9:19] Enus Linden: yes please. i'll also extend login in 'stock'python to the extent that i can, and use a simplle test ex ample as well
  • [9:19] Infinity Linden: but only if it doesn't get in the way of us getting our stuff done in a "reasonable" amount of time
  • [9:19] Tao Takashi: e.g. it would also be great to be able to use parts of the libs inside some agent domain without copying code to get rid of dependancies
  • [9:20] Infinity Linden: where the definition of "reasonable" is left as an exercise for the reader
  • [9:20] Enus Linden: btw, i am on 'vacation' for the next 3 weeks, but will be owrking to a degree. certainly around for meetnigs when possible, and to move this forward
  • [9:20] Tao Takashi: I think it's needs a little bit of getting used to the ZCA way but I at least don't want to miss it anymore
  • [9:20] Infinity Linden: and I'm the one who
  • [9:20] Enus Linden: so: test cases...
  • [9:20] Infinity Linden: I'm the one who's volunteered to write teh test cases
  • [9:20] Infinity Linden: using Enus' framework
  • [9:21] Tao Takashi: sometimes people go overboard with it though and add too many layers but this can always be refactored
  • [9:21] Enus Linden: infinity wants to start by 'testing the hell out of login'
  • [9:21] Enus Linden: i do too
  • [9:21] Tao Takashi: I guess you are planning on doing unit tests and not doctests?
  • [9:22] Enus Linden: i need to learn about doctests, i have experience with unittests
  • [9:22] Saijanai Kuhn: One other thing we need to talk bout is the idea of multiple agents running in the scame script
  • [9:22] Morgaine Dinova: Tao: but non-trivial things so rarely get refactored after original design, even in the cases when everyone knows it's needed.
  • [9:22] Enus Linden: sai, that's all in implementation of the application or test
  • [9:22] Infinity Linden: yeah... I'm thinking more of unit tests on up through "behavioral tests"
  • [9:22] Enus Linden: we build a library that enables the definition of an agent and an agent's actions
  • [9:22] Saijanai Kuhn: true, but "testing the hell out of login" is the first usecase for that, I think
  • [9:23] Enus Linden: what is done with that is purely up to the developer
  • [9:23] Enus Linden: unit testing the hell out of login is first priority
  • [9:23] Enus Linden: the performance testing
  • [9:23] Infinity Linden: apparently "Behavioral Tests" has overtaken "Test Driven Development" as the catch-phrase of choice
  • [9:23] Enus Linden: which is different thatn uni tests
  • [9:24] Infinity Linden: oh.. speaking of performance testing...
  • [9:24] Infinity Linden: does anyone here use a formal "Separation of Concerns" model?
  • [9:24] Enus Linden: infinity plans to start sketching out test cases, which i hope to post to wiki for feedback and augmentation...
  • [9:24] Tao Takashi: Morgaine: because usually it's a pain. ZCA and good test coverage could help that
  • [9:24] Enus Linden: locklainn will be helping build out the libs and tests as we go
  • [9:24] Morgaine Dinova: Tao: hopefully
  • [9:24] Infinity Linden: Cross-cutting concerns will be a pain to test, but we might want to think about it a bit up front
  • [9:24] Saijanai Kuhn: also, whilethis makes it very Python dependent, the use of eventlet for communications handling will make the scripts much lighter, from what I can understand
  • [9:25] Tao Takashi: and it was a pain because it was all one big blob
  • [9:25] Tao Takashi: in Plone nearly everythign was refactored by now ;-)
  • [9:25] Tao Takashi: I can also help with doctest examples maybe
  • [9:25] Tao Takashi: I would at least like it for the lib because it's then also documentation for the lib
  • [9:26] Tao Takashi: and as I am also in #europython right now to discuss the conference, anybody coming eventually? :-)
  • [9:26] Tao Takashi: we could make a pyogp sprint there
  • [9:26] Morgaine Dinova: Inifnity: separation of concerns is more of a system design issue. System testing is very often cross-cutting, even if only by scripted orchestrating of well-separated unit tests.
  • [9:26] Saijanai Kuhn: I think we nee dto have some kind of tutorial on how to use eventlet and friends
  • [9:27] Enus Linden: so zca/no zca, buildout?, doctest? (i want lib docs as well tao) test cases. i owe more and more docs. we all have our homework....
  • [9:27] Hamilton Linden: / gotta run to next meeting cya
  • [9:27] Enus Linden: irc.freenode.com: #pyogp
  • [9:27] Morgaine Dinova: Cya Hamilton
  • [9:27] Saijanai Kuhn: bye hamilton
  • [9:27] Enus Linden: come have a chat
  • [9:27] Tess Linden: I gotta run too. thanks Enus
  • [9:27] Enus Linden: curious: who else has interest in 1. contributing to the creation of these libs and tess?
  • [9:27] Saijanai Kuhn: If you ever forget the contact points: [10]
  • [9:27] Morgaine Dinova: Cya Tess
  • [9:27] Saijanai Kuhn: bye tess
  • [9:27] Infinity Linden: cya tess
  • [9:28] Dahlia Trimble: bye :)
  • [9:28] Enus Linden: 2. using the libs once mature-ish
  • [9:28] Bartholomew Kleiber: I have
  • [9:28] Saijanai Kuhn: /raise /raise
  • [9:28] Enus Linden: pyogpbots will be tasty
  • [9:28] Enus Linden: bye tess
  • [9:28] Saijanai Kuhn: i think that everybody that want to mod they viewer will want to use the tests
  • [9:29] Morgaine Dinova: Enus: hopefully pretty much everyone can supply tests, even if they're not involved in harness development.
  • [9:29] Morgaine Dinova: Haha
  • [9:29] Infinity Linden: hmm.. just noticed that "Tess" is "Tests" without the final 't'. I think that's a good sign
  • [9:29] Enus Linden: lol
  • [9:29] Tao Takashi: maybe people can already add test descriptions to the wiki
  • [9:29] Tao Takashi: and think of what can go wrong
  • [9:30] Infinity Linden: An additional objective of the test framework is peeps can use them to report bugs
  • [9:30] Enus Linden: morgaine: good point... i'd like to see the code mature in such a way that we can test the protocols as implemented wherever they are implemented
  • [9:30] Tao Takashi: it probably would be good to have such a description for every functionality we define
  • [9:30] Enus Linden: yes tao
  • [9:30] Morgaine Dinova: Tao: No reason why the test system can't be wiki-driven :-)
  • [9:30] Infinity Linden: so making tests "easy" so as many people can use them as possible is double-plus-good
  • [9:30] Enus Linden: """ desc """ is our friend
  • [9:31] Enus Linden: k all, i've gotta run myself....
  • [9:31] Enus Linden: thanks for chatting
  • [9:31] Saijanai Kuhn: laters
  • [9:31] Saijanai Kuhn: bye enus
  • [9:31] Locklainn Linden: see ya enus
  • [9:31] Dahlia Trimble: bye ;0
  • [9:31] Enus Linden: i look forward to really getting this rolling in the next week or so
  • [9:31] Saijanai Kuhn: don't forget the irc
  • [9:31] Dahlia Trimble:  :)
  • [9:31] Infinity Linden: Cheers E
  • [9:31] Morgaine Dinova: Infinity: even tests from "abusers" might help, if it ends up tightening up the system.
  • [9:31] Morgaine Dinova: Cya Enus
  • [9:31] Infinity Linden: Carp! is it really 930 already?
  • [9:31] Infinity Linden: I gotta run as well
  • [9:32] Morgaine Dinova: Cya Infinity
  • [9:32] Infinity Linden: cheers everyone!
  • [9:32] Saijanai Kuhn: bye infinity
  • [9:32] Bartholomew Kleiber: bye all
  • [9:32] Saijanai Kuhn: bye barth
  • [9:32] Dahlia Trimble: bye Infinity :)
  • [9:32] Enus Linden: i
  • [9:32] Morgaine Dinova: Cya Barth
  • [9:32] Enus Linden: 'll post chat log...
  • [9:32] Infinity Linden: just so everyone knows... Enus and I will be hoping to present something more substatntial on Tuesda
  • [9:32] Morgaine Dinova: Super
  • [9:32] Infinity Linden: and I'll likely be hovering in #pyogp
  • [9:32] Infinity Linden: and...
  • [9:32] Tao Takashi: me, too :)
  • [9:33] Infinity Linden: if you see me in a public channel, it means I'm willing to be talked to
  • [9:33] Infinity Linden: cheers, all!
  • [9:33] Tao Takashi: cheers! :)
  • [9:33] Saijanai Kuhn: cheer
  • [9:33] Saijanai Kuhn: cheers*
  • [9:33] Morgaine Dinova: Cya Chi
  • [9:33] Enus Linden: XD
  • [9:33] Dahlia Trimble: bye :)
  • [9:33] Locklainn Linden: see ya
  • [9:34] chieni Beck: bye all
  • [9:34] Saijanai Kuhn: bye locklainn
  • [9:34] Saijanai Kuhn: bye chieni
  • [9:34] Morgaine Dinova: Cya Lock
  • [9:34] Saijanai Kuhn: was anyone here for the entire meeting? I crashed about times :-( so no transcript from me
  • [9:34] Dahlia Trimble: follows the crowd out the door.... bye all
  • [9:34] Morgaine Dinova: Cya Dahlia
  • [9:34] Tao Takashi: I came later. but to sum it up: we look into ZCA, buildout, doc tests and will meet again tuesday with results
  • [9:34] Saijanai Kuhn: was sai. wait a few seconds and u i will get tu the transcript