User:Enus Linden/Office Hours/2008 August 29

• [9:33] Enus Linden: so we might as well get started
• [9:33] Enus Linden: i was hoping to give a quick update on where pyogp is
• [9:33] Enus Linden: and then explore where we can take it next.
• [9:34] Enus Linden: I'd like to hear what sort of uses people might find most valuable to them in a thin client like pyogp...
• [9:34] Enus Linden: so per status
• [9:34] Enus Linden: pyogp basically can handle all of the communication building blocks that are needed to be a proper client
• [9:34] Enus Linden: TCP/UDP, authentication, can speak caps, etc
• [9:35] Tao Takashi: Hi
• [9:35] Enus Linden: but only the base layers are there
• [9:35] Enus Linden: Yay Tao!
• [9:35] Squirrel Wood: Will it also work in company networks where http/https requests must go through a proxy ?
• [9:35] Enus Linden: we are incorporating logging and exception handling now
• [9:35] Teravus Ousley: heh, dahlia wrote a prim-mesher in blender python..
• [9:36] Enus Linden: well, I'm Nat-ed and it works for me
• [9:36] Teravus Ousley: shhhs
• [9:36] Tao Takashi: I think urllib takes proxy settings into account but I have to check
• [9:36] Saijanai Kuhn: Squirrel, that would be the same as asking if the SL client or libsl can do that
• [9:36] Tao Takashi: but of course you might then still have a problem with UDP
• [9:36] Enus Linden: but we should explicitely explore proxying
• [9:36] Saijanai Kuhn: I think
• [9:36] Sea Urchin: beanbag: Going to next texture.
• [9:36] Enus Linden: right
• [9:36] Enus Linden: the proxy needs to accomodate the port range for udp
• [9:37] Enus Linden: etc
• [9:37] Tao Takashi: we need to look at networking anyway
• [9:37] Enus Linden: logging and exceptions are in the trunk now for review
• [9:37] Tao Takashi: only in caps.py
• [9:37] Enus Linden: right
• [9:37] Tao Takashi: I will add more as time permits
• [9:38] Enus Linden: i'll have feedback no sooner than Tuesday on that Tao
• [9:38] Enus Linden: monday is a holiday in the US
• [9:38] Enus Linden: (yay)
• [9:38] Tao Takashi: as long as it's no problem if I move along anyway that's ok
• [9:38] Enus Linden: no prob imo
• [9:38] Tao Takashi: but I am not sure how much time I will have anyway, we'll see
• [9:38] Enus Linden: so we are nearing a body of work that we can tag and set aside as stable
• [9:39] Tao Takashi: I also wanted to actually test the full lib with some example client
• [9:39] Enus Linden: then we can move on to bigger and better things
• [9:39] Enus Linden: that is something we ought to talk about Tao
• [9:39] Enus Linden: how to go about an example client
• [9:39] Tao Takashi: the question is when I should test it with twisted, before or after that tag
• [9:39] Tao Takashi: because it might mean some changes
• [9:39] Enus Linden: ought there be pyogp.client?
• [9:39] Enus Linden: after imo Tao
• [9:40] Enus Linden: would be nice to have a stable set of libs to fall back on
• [9:40] Tao Takashi: I don't think so (client). I think there should be mainly examples but not THE client
• [9:40] Saijanai Kuhn: well that seques into the GUI situation. wx crashes python on my Mac, so its Tkinter for me
• [9:40] Tao Takashi: I think so too regarding the tag
• [9:40] Tao Takashi: but I might experiment in a branch
• [9:41] Enus Linden: ah, that reminds me, we ought to publish svn steps for branching and merging
• [9:41] Enus Linden: so those who do it can all do it more or less similarly
• [9:41] Tao Takashi: it's just according the book
• [9:41] Paul Bumi: my cam went of the sim
• [9:41] Paul Bumi: lol
• [9:41] Tao Takashi: but it's a pain anyway
• [9:41] Tao Takashi: as for clients I would propose to create example clients in pyogp.sandbox
• [9:41] Tao Takashi: so we learn what is needed and what they can have in common
• [9:42] Saijanai Kuhn: also, a reminder: for anyone who wishes to be a pyogp contributor, you can sign a form at wingware.com and get a free professional copy of WingIDE for pyogp development (Python-oriented IDE)
• [9:42] Tao Takashi: so we can add another layer of functionality on top of the base lib
• [9:42] Enus Linden: that is what i was hoping would be preferred Tao
• [9:42] Enus Linden: adding layers to the lib
• [9:42] Enus Linden: as opposed to having them in a separate package
• [9:42] Tao Takashi: well, I meant separate packages ;-)
• [9:43] Enus Linden: oh
• [9:43] Enus Linden: bummer :)
• [9:43] Enus Linden: so lets explore
• [9:43] Tao Takashi: they are more easily replaceable then
• [9:43] Enus Linden: true
• [9:43] Tao Takashi: like somebody who does not like some abstraction we made can do her own
• [9:43] Tao Takashi: the "market" can then decide what's best
• [9:43] Enus Linden: so the base lib contains essentially what it does now: building blocks and base functionality
• [9:44] Tao Takashi: yes, maybe the agentdomain stuff etc. should already be moved out when we know more about these components
• [9:44] Enus Linden: one of the next phases of work i think includes handlers for UDP packets
• [9:44] Tao Takashi: like the Agent object, Avatar object and so on.. they are only placeholders for now anyway
• [9:44] Saijanai Kuhn: votes for group IM
• [9:45] Enus Linden: Sai, you can set that up with the components that exist now :)
• [9:45] Tao Takashi: but I really only know about next steps after having played around with some application
• [9:45] Saijanai Kuhn: chat client is single mostimportant usecase for a thing client for most people
• [9:45] Saijanai Kuhn: thin* client
• [9:45] Enus Linden: so what could next steps be?
• [9:45] Saijanai Kuhn: Enus, I can set that upu with my own python script... except I never got it to work
• [9:46] Tao Takashi: for now I would say: finish logging and exceptions, maybe rename the message_* files to just * and move the message template from data/ to message_system/
• [9:46] Enus Linden: all of that can be done relatively easily before the tag
• [9:46] Tao Takashi: then maybe writing some simple example scripts (or copy stuff from testharness) into some examples lib
• [9:46] Tao Takashi: yes
• [9:46] Tao Takashi: should be before the tag
• [9:46] Enus Linden: btw, anyone who wants to dev on python, please let us know :)
• [9:47] Enus Linden: we are down to 1 1/8 python folks now with Locklainn gone
• [9:47] Saijanai Kuhn: looks at himself. Amazingly fat 1/8 developer
• [9:47] Movies1963 Beck: where'd he or she go
• [9:47] Enus Linden: Locklainn went on to the next chapter of his life
• [9:47] Enus Linden: i hope he comes back
• [9:47] Saijanai Kuhn: back to school
• [9:48] Movies1963 Beck: was he a member or a Linden
• [9:48] Enus Linden: Linden
• [9:48] Enus Linden: for 2 1/2 months
• [9:48] Saijanai Kuhn: was he A Google Suer of COde person?
• [9:48] Movies1963 Beck: sometimes it's not all about the 401k and free buffet lunches
• [9:48] Saijanai Kuhn: Summer of Code?
• [9:48] Tao Takashi: I would also propose that we branch a 0.1 instead of a tag and work on 0.2 in trunk while bugfixes stay in 0.1 branch
• [9:49] Enus Linden: so once the work for tha tag is complete, and we have 0.1 (branch or tag :P), what comes with 0.2?
• [9:49] Enus Linden: and why a branch and not a tag tao?
• [9:49] Tao Takashi: in order to release bugfixes if necessary
• [9:49] Enus Linden: sure, but no tag?
• [9:50] Tao Takashi: well, then you cannot checkin for it anymore if 0.2 development has started
• [9:50] Tao Takashi: like for 0.1.1
• [9:51] Enus Linden: well, we could certainly do both a tag and a 0.1.1 bug fix branch couldn't we?
• [9:51] Tao Takashi: well, we should probably create tags additionally
• [9:51] Enus Linden: i'd like to be able to checkout 0.1 in a stable state when i want to without having to look for revision numbers
• [9:51] Tao Takashi: yep, both then
• [9:51] Tao Takashi: one 0.1 branch from which we can create tags for releases
• [9:51] Enus Linden: k
• [9:52] Tao Takashi: as for 0.2 it depends on some experiments first I think. I would like to be clear if the lib supports all use cases regarding networking
• [9:52] Tao Takashi: and I still think that probably the main network core needs to be in the app. maybe the lib can provide building blocks though
• [9:52] Tao Takashi: but we will see then I guess
• [9:53] Tao Takashi: then we can discuss what can be abstracted from the base message stuff
• [9:53] Tao Takashi: in the end I guess we don't want to build packets manually
• [9:53] Enus Linden: the first feature work i'd like to see, would be integrating the ability to login to a nonOGP grid
• [9:53] Tao Takashi: we might want to say avatar.standup()
• [9:53] Enus Linden: that is a small set of work
• [9:53] Tao Takashi: you mean XMLRPC?
• [9:53] Enus Linden: then, i want the abstraction you are talking about
• [9:53] Saijanai Kuhn: probably llsd would be better
• [9:54] Tao Takashi: well, legacy login
• [9:54] Enus Linden: llsd is adequate
• [9:54] Tao Takashi: I would propose to use pyogp.legacy for that
• [9:54] Tao Takashi: so an app can choose to import it and use it if it wants to
• [9:54] Tao Takashi: it probably should return something then which is compatible with the rest of pyogp
• [9:54] Tess Linden: legacy login will be deprecated though
• [9:55] Enus Linden: yes Tess, in OGP it will
• [9:55] Enus Linden: but i want to be able to run pyogp against agni now for example
• [9:55] Tao Takashi: I also would like the ability to login for normal SL
• [9:55] Tao Takashi: for griefing purposes and such
• [9:55] Tao Takashi: griefing Lindens mostly
• [9:55] Enus Linden:  :)
• [9:55] Enus Linden: i want to drop a bot into groups so i can keep up with the latest Sai spammings
• [9:56] Saijanai Kuhn: I want to tie Sai to a timer so I can just have him spam at the right times while I'm fixing breakfast
• [9:56] Flight Band: All Go
• [9:57] Enus Linden: so per the anstraction payer on top of packets
• [9:57] Tao Takashi: so people want avatar.spam()
• [9:57] Tao Takashi: so lots of use cases here, great
• [9:57] Enus Linden: that will enable huge amounts of functionality
• [9:57] Tess Linden: hm, its not deployed to agni right?
• [9:57] Enus Linden: and his a giant chunk of code
• [9:57] Enus Linden: no tess, ogp isnt
• [9:57] Tess Linden: I think it'll be deprecated before it goes on agni though
• [9:57] Enus Linden: but pyogp.legacy could log in to our current prod login protocols, and connect to a sim
• [9:57] Tao Takashi: well, the first step would be handlers and some event system I think
• [9:57] Tess Linden: ohh sorry, i got confused
• [9:57] Tao Takashi: so handlers get called on packets they subscribed to
• [9:58] Saijanai Kuhn: the only real difference is prsence. Acking UDP keeps presence going, period, in agni
• [9:58] Tao Takashi: for now these can be message objects I think
• [9:58] Tess Linden: (I thought you were talking about the legacy login OGP resource)
• [9:58] Enus Linden: and does so in ogp wrt sim presence sai
• [9:58] Tao Takashi: at least at the moment
• [9:58] Saijanai Kuhn: right
• [9:58] Tao Takashi: the question is what will happen in the future if maybe OGP moves more and more away from what SL is today
• [9:59] Tao Takashi: which also might depend on the LL strategy on deploying OGP
• [9:59] Enus Linden: well, the AD plans on taking on more functionality as it gets built out
• [9:59] Tao Takashi: but we will see then
• [9:59] Enus Linden: we'll have to accomodate
• [9:59] Tao Takashi: probably mostly the application has to accomodate
• [10:00] Saijanai Kuhn: Well, the current OGP, except for login/TP, is 100% identical to the agni system, so that will remain functional for agni support
• [10:00] Tao Takashi: I think it cannot be transparent at that level anyway
• [10:00] Tess Linden: we need to have some compelling use case for residents, such as visiting external regions
• [10:00] Tao Takashi: Sai: but this will change so we have to accomodate
• [10:00] Tess Linden: and think about how much of the protocol will need to be flushed out for those use cases
• [10:00] Saijanai Kuhn: sue, but that's n the OGP side. legacy shouldn't change substantially until OGP starts appearing on agni
• [10:00] Tao Takashi: Tess: but maybe you could internally already switch to some OGP model even if this feature is not yet enabled
• [10:01] Tao Takashi: Sai
• [10:01] Tao Takashi: this depends on how LL plans to deploy it
• [10:01] Tao Takashi: if it's done when it's finished or step by step
• [10:01] Tao Takashi: but in either case something needs to be changed to make it worked and can be changed to work
• [10:01] Tao Takashi: we just have to check back then
• [10:01] Tao Takashi: and move stuff around accordingly
• [10:01] Saijanai Kuhn: sure, but I don't see it as a huge design issue. at least at this point
• [10:01] Tess Linden: deployment will be a little tricky, but we will try to do it het-grid style to avoid problems
• [10:02] Tao Takashi: probably it's a good idea anyway not to wait for 1.0 before deploying it
• [10:02] Saijanai Kuhn: I think that is where Tao's python-based AD will come in REAL handy, Tes
• [10:02] Enus Linden: back to packets: so similar to libomv (libsl) i see value in multiple layers of abstraction wrt packets
• [10:02] Enus Linden: a layer of handlers
• [10:02] Tao Takashi: what exactly does it do?
• [10:03] Tao Takashi: can you give us some example? It's long ago since I looked at that code
• [10:03] Enus Linden: and a layer that can group similar functionality together
• [10:03] Tess Linden: Sai: I dont think we're there yet because we don't have a fully functional usable thing yet since the Beta does not transfer appearance, and we think that is required for a good experience
• [10:03] Tao Takashi: you mean that it handles several packets which need to go together to provide some functionality?
• [10:03] Enus Linden: it's more like grouping packets which operate in similar areas together
• [10:03] Tao Takashi: I could think of some chat module which handles sending and receiving and such
• [10:04] Saijanai Kuhn: Tess, of course
• [10:04] Enus Linden: e.g. the appearance manager
• [10:04] Enus Linden: or groups.cs
• [10:04] Tao Takashi: so it gives you an abstract interface for handling groups?
• [10:04] Tao Takashi: without knowing the packets involved?
• [10:04] Enus Linden: which includes parameter parsing logic and wraps it around the packets
• [10:04] Enus Linden: yes tao
• [10:05] Saijanai Kuhn: well,m there are also itneractions within the system that are required to handle a given functionality. E.G. gorup IM needs to obtain info from EQG andn populate ImrpovedInstantMssage
• [10:05] Tao Takashi: ok, then we are on the same page
• [10:05] Enus Linden: that is a perfect use case
• [10:05] Tao Takashi: right, IM might also be such an area
• [10:05] Tao Takashi: or even the perfect area :)
• [10:05] Tao Takashi: but I think this needs a little bit of thinking and experimentation which might come out of experimenting with some clients
• [10:05] Enus Linden: as it mixes different base level functionality and their respective abstracted layer into one feature set in a client
• [10:06] Tao Takashi: my next step is thus to try one of Locklainn's examples
• [10:06] Enus Linden: i can't believe it, sai has us on the brink of working on group im
• [10:07] Tao Takashi: I didn't had time to even look at them unfortunately
• [10:07] Enus Linden: nor have i tao
• [10:07] Saijanai Kuhn: I chose group IM for a reason. It seemed doable but complicated enough to end up documenting lots of parts of the system
• [10:07] Enus Linden: so for others present, do you have any desires to see where pyogp goes?
• [10:07] Tao Takashi: I also need to work on my AD to find a way to work around the caps limitations
• [10:07] Tao Takashi: in order to make it somewhat secure
• [10:08] Enus Linden: there are lots of UUIDs out there tao. the risk of finding an active one is low isnt it?
• [10:08] Tao Takashi: I also need some sort of client actually to demonstrate OAuth and XRDS uses, maybe OpenSocial as well
• [10:08] Saijanai Kuhn: I see three main uses for pyogp: test harnes (multiple avie eventually), thin client and prxy ala LSproxy
• [10:08] Tao Takashi: Enus: right but right now I don't use UUIDs
• [10:08] Enus Linden: oh yes, proxy
• [10:08] Tao Takashi: as caps need some sort of firewall and proxy
• [10:08] Saijanai Kuhn: SLPRoxy
• [10:09] Tao Takashi: which is some sort of an obstacle in easy deployment
• [10:09] Tao Takashi: and incompatible with how web frameworks work
• [10:09] Tao Takashi: so that's why I need to find a way around this
• [10:09] Saijanai Kuhn: monitoring packets is a pain without SLproxy but the OGP packets are always going to appear in libsl kinda late in th egame
• [10:10] Tao Takashi: if logging is in place it should be quite easy to log packets by using a logger for them
• [10:10] Tao Takashi: maybe I should tackle that next and write an example client
• [10:10] Tao Takashi: for logging
• [10:10] Enus Linden: then i think it would be great fopr that to be on the plate for 0.2
• [10:11] Tao Takashi: should be already part of 0.1 as it's then just involving a client which prints the packets
• [10:11] Tao Takashi: as long as it's only printing them
• [10:11] Tao Takashi: injecting might be a different story but I would see this more in some application than the lib
• [10:11] Enus Linden: can we print multiple versions of the packets then?
• [10:11] Enus Linden: raw
• [10:11] Enus Linden: and formatted to make sense?
• [10:11] Tao Takashi: depends on what we implement as loggers
• [10:11] Tao Takashi: we can have 2 loggers
• [10:11] Tao Takashi: and you select the one you want to use
• [10:11] Tao Takashi: or both
• [10:12] Tao Takashi: and you can then even define separate logfiles etc.
• [10:12] Tao Takashi: so I will add the next loggers to these parts then
• [10:12] Enus Linden: packet injection can be deferred tho, logging only for now :)
• [10:12] Sea Urchin: beanbag: Going to next texture.
• [10:13] Tao Takashi: one could write a packet builder in wx ;-)
• [10:13] Saijanai Kuhn: wx crashes on my Mac
• [10:13] Tao Takashi: Hm, can you send me the code so I can test it on mine?
• [10:13] Tao Takashi: I only ran some example by now and this seemed to work
• [10:13] Saijanai Kuhn: any and all example code with the module
• [10:13] Saijanai Kuhn: pakage
• [10:14] Sea Urchin: beanbag: Going to next texture.
• [10:14] Tao Takashi: you mean that editor for instance?
• [10:14] Saijanai Kuhn: anythign at all. doesn't recognize the wx.Frame for example
• [10:14] Sea Urchin: beanbag: Going to next texture.
• [10:14] Tao Takashi: what version did you install?
• [10:14] Sea Urchin: beanbag: Going to next texture.
• [10:14] Sea Urchin: beanbag: Going to next texture.
• [10:14] Sea Urchin: beanbag: Going to next texture.
• [10:14] Tao Takashi: or maybe you can send me the URLs of what you installed
• [10:14] Saijanai Kuhn: course I installed the very latest version 1.8.1 or whatever
• [10:15] Tao Takashi: please send me URLs nevertheless if possible
• [10:15] Tao Takashi: so we can be sure that we use the same version
• [10:15] Enus Linden: so to circle back to 0.1, i'd like to talk about interop tests for a moment. they destabilized at some point and are need of docs that make things clearer. Sai, would you be up for pairing up with me on those at some point next week?
• [10:15] Sea Urchin: beanbag: Going to next texture.
• [10:15] Sea Urchin: beanbag: Going to next texture.
• [10:16] Tao Takashi: maybe look at the sphinx website on how to set it up and try to use it
• [10:16] Saijanai Kuhn: [1] Python 2.5 unicode
• [10:16] Saijanai Kuhn: I guess I could try the ansi instead
• [10:16] Saijanai Kuhn: Tao Absolutely. I need to learn how todo this stuff
• [10:17] Enus Linden: we are quieting down. i take that as a sign that we could possibly retire the meeting
• [10:17] Enus Linden: any other issues to discuss today?
• [10:17] Tao Takashi: Not from me, I also need to head home
• [10:18] Enus Linden: meeting adjourned then
• [10:18] Enus Linden: thanks all
• [10:18] Saijanai Kuhn: Thanks Enus
• [10:18] Enus Linden: waves bye bye
• [10:19] Teravus Ousley: waves
• [10:20] Tess Linden: bye!