Open in new window / Try shogun cloud
--- Log opened Sat Jun 11 00:00:17 2011
-!- ins__ [] has quit [Ping timeout: 240 seconds]01:27
-!- in3xes_ [~in3xes@] has joined #shogun04:09
-!- in3xes [~in3xes@] has quit [Ping timeout: 276 seconds]04:13
-!- in3xes_ is now known as in3xes05:01
-!- in3xes_ [~in3xes@] has joined #shogun07:06
-!- in3xes [~in3xes@] has quit [Ping timeout: 276 seconds]07:10
-!- in3xes1 [~in3xes@] has joined #shogun07:18
-!- in3xes_ [~in3xes@] has quit [Ping timeout: 276 seconds]07:22
-!- in3xes_ [~in3xes@] has joined #shogun07:49
-!- in3xes1 [~in3xes@] has quit [Ping timeout: 276 seconds]07:52
-!- in3xes_ is now known as in3xes08:40
-!- in3xes [~in3xes@] has quit [Ping timeout: 276 seconds]10:47
-!- in3xes [~in3xes@] has joined #shogun10:47
-!- alesis-novik [] has joined #shogun13:49
-!- blackburn1 [~blackburn@] has joined #shogun14:21
-!- blackburn1 is now known as blackburn14:21
-!- blackburn1 [~blackburn@] has joined #shogun17:42
-!- blackburn [~blackburn@] has quit [Read error: No route to host]17:42
-!- blackburn1 [~blackburn@] has quit [Ping timeout: 240 seconds]18:03
-!- blackburn [~blackburn@] has joined #shogun18:04
-!- serialhex [] has quit [Remote host closed the connection]18:16
-!- blackburn1 [~blackburn@] has joined #shogun18:17
-!- blackburn [~blackburn@] has quit [Ping timeout: 255 seconds]18:17
-!- blackburn [~blackburn@] has joined #shogun19:19
-!- blackburn1 [~blackburn@] has quit [Ping timeout: 276 seconds]19:20
-!- blackburn [~blackburn@] has quit [Ping timeout: 240 seconds]20:02
-!- blackburn [~blackburn@] has joined #shogun20:03
-!- f-x [~user@] has joined #shogun20:47
-!- cwidmer [] has joined #shogun21:05
@sonney2kblackburn, back21:14
f-xsonney2k: hey! is the get_feature_vector(float64_t** dst, int32_t* len, int32_t num) in DotFeatures used anywhere?21:21
f-xor is it always supposed to be reimplemented in a derived class?21:21
f-xi'm asking since DotFeatures is not supposed to be specific to a data type (eg. float64_t) but in the definition dst is explicitly mentioned as float64_t21:22
@sonney2kf-x, it is actually using the add operation to create the feature vector21:23
@sonney2kand add is using float64_t*21:23
f-xok.. so is it possible to use DotFeatures as a standalone features class?21:24
f-xor do you have to use one of the derived classes like SimpleFeatures<T> ?21:24
CIA-18shogun: Sergey Lisitsyn master * r24b8f99 / (4 files in 2 dirs): Added CIsomap -
@sonney2kf-x, dotfeatures itself needs some derived feature class (in which the add etc operations are defined)21:25
CIA-18shogun: Soeren Sonnenburg master * rd761ec2 / examples/undocumented/ruby_modular/classifier_libsvm_minimal_modular.rb : Merge branch 'master' of git:// -
f-xhmm.. add_to_dense_vec hasn't been defined in DotFeatures21:27
@sonney2kf-x, note that get_feature_vector of dot features cannot be fast as it uses add to compute the vector21:28
@sonney2kf-x, exactly21:28
f-xsonney2k: so is the get_feature_vector() of dotfeatures used anywhere? i see it has been redefined in simplefeatures21:30
@sonney2kf-x, I think every sensible feature class redefines it for speed reasons21:30
f-xyeah, it seems so21:31
f-xand btw i mailed you about a possible inheritance method21:31
f-xbut for that StreamingFeatures will have to be templated21:31
f-xand i guess some derivations in DotFeatures and SimpleFeatures etc will have to be made virtual21:32
@sonney2kf-x, I've seen your mail but didn't have time yet to read it in detail will do this evening21:34
f-xok sure21:34
f-xjust wanted to know if there were any glaring problems with that21:34
f-xi'm trying to change stuff according to that right now, will see if things work out21:35
-!- cwidmer [] has quit [Quit: - Chat comfortably. Anywhere.]21:38
blackburnsonney2k: here21:39
blackburnsonney2k: Chris will sent you my 'objectives' for mid-term21:39
blackburnwe just had had a discuss about goals and so on21:39
@sonney2kblackburn, very good21:40
blackburnsonney2k: about my issues with distances - I think I have solved it21:40
@sonney2kblackburn, even better :D21:40
blackburnsonney2k: in the version you've pushed isomap is duplicated to classicmds21:41
blackburnsonney2k: need your opinion21:41
@sonney2kf-x, btw did you finish the getline thing I mean using some buffer?21:41
f-xsonney2k: that problem isn't sorted yet21:41
f-xabout the file pointer not being immediately after the \n21:41
f-xafter every call to getline21:41
f-xfgets() seems a more direct route now21:42
f-xi haven't done it yet21:42
blackburnI have to use geodesic distance (just shortest paths between all objects) and now it is just computed inside Isomap routines - shall I create that specific distance?21:42
f-xso is it okay that the file pointer is at some unexpected position after a getline?21:43
@sonney2kf-x, if you make it a function of ascii file - sure21:44
@sonney2kI mean ascii file is line based and so it will only ever call getline repeatedly21:44
f-xokay, i think i'll just call it something other than 'getline' as that would confuse users21:45
@sonney2kblackburn, wow! just got chris' email21:45
@sonney2kblackburn, lots of things you intend to finish21:45
@sonney2kblackburn, when is your last exam?21:45
blackburnsonney2k: why lots? :)21:46
blackburnLLE, classic MDS and Isomap is ready21:46
blackburnonly LMDS to be implemented21:46
@sonney2kblackburn, great - that almost leaves you with 1 month after your exams to recover and code21:46
blackburnsonney2k: yeap, right after my exams serious work would be started :D21:47
blackburnsonney2k: is it ok to delete and replace features in apply_to_feature_matrix?21:50
@sonney2kblackburn, you can totally modify feature matrix (and reduce its size) - but tha't sit22:02
blackburnsonney2k: well I have two ways:22:03
blackburnmethod apply_to_distance returning CSimpleFeatures*22:03
blackburnor method apply_to_distance using some args to return matrix22:04
blackburnthe only problem: is it possible to 'typemap' this arg list: (CDistance, float64_t*, int32_t, int32_t)?22:04
blackburnI mean in python it should be: preprocessor.apply_to_distance(dist) and returning matrix or features22:05
blackburnah I think I have an idea22:06
blackburnCSimpleFeatures<float64_t>* apply_to_distance(CDistance* distance);               for modular22:06
blackburnvoid apply_to_distance(CDistance* distance, float64_t* dst, int32_t rows, int32_t cols);              for internals22:07
@sonney2kblackburn, what is wrong with SGMatrix?22:07
@sonney2kf-x, I read your email now22:07
blackburnsonney2k: you mean why I don't use SGMatrix?22:07
@sonney2kblackburn, instead of float64_t* dst, int32_t rows, int32_t cols22:08
blackburnsonney2k: it is not a solution anyway but yes, I'll refactor to it SGMatrix a bit later22:08
f-xsonney2k: any suggestions?22:08
@sonney2kblackburn, why not? then it is typemapped22:09
blackburnseems trying to explain problem helps to understand ways to solve :)22:09
@sonney2kf-x, I really would like to avoid multiple inheritance22:09
f-xsonney2k: that would be ideal... but how else do we make streaming simplefeatures compatible with dotfeatures and simplefeatures?22:11
@sonney2kf-x, I don't mind streaming features to become a templated class - however I would split it up into say StreamingStringFeatures, StreamingSimpleFeatures, StreamingSparseFeatures22:11
f-xyes, that has to be done22:11
f-xStreamingSimpleFeatures would be further templated22:12
@sonney2k(and each of them tempalted)22:12
f-xso you mean to say StreamingFeatures<T> is okay?22:12
@sonney2kis ok22:12
f-xStreamingSimpleFeatures<T>: public StreamingFeatures22:13
@sonney2kI am not sure what StreamingFeatures<T> should be22:13
f-xlike this?22:13
f-xthe template in StreamingFeatures is for the buffer to know what kind of data it is storing22:13
f-xwhile allocating memory, i've hardcoded new float64_t[size] into the buffer/parser code22:13
f-xi was thinking that should be replaced with new T[size] to make it more general22:14
@sonney2kf-x, but you cannot derive from general templated classes22:14
blackburnsonney2k: is it ok to you to use RowMajor (not ColumnMajor) in algos?22:14
@sonney2kblackburn, why would one?22:14
f-xsonney2k: hmm... i thought you just had to put the method definitions in the .h file and it was fine22:14
blackburnsonney2k: don't know, it is implemented this way now in LLE and MDS22:15
f-xcan you give me an example of something which you think won't work?22:15
f-xso that i can test it22:15
blackburnI could change it if it is not ok :)22:15
@sonney2kf-x, StreamingSimpleFeatures<T>: public StreamingFeatures<T>22:15
f-xsonney2k: so you're sure that won't work?22:16
@sonney2kblackburn, I mean all matrices and everything in shogun are column major (like lapack likes it)22:16
@sonney2kit makes only sense to deviate from that if it is faster in your setup22:16
f-xright now the basic 'example' class is defined with float64_t* fv22:16
f-xand i'd really like it if it was more generalized22:17
blackburnsonney2k: okay, I will change it22:17
blackburnmost of matrices anyway are symmetrical22:17
f-xso the templating begins all the way from example<T>, buffer<T>, parser<T>, streamingfeatures<T> ...22:17
@sonney2kblackburn, if they are symmetric it doesn't really matter right :)22:18
@sonney2kf-x, well you have this thing
f-xyes, i'd have to use all those this->member22:18
f-xor "using x::y"22:18
blackburnsonney2k: exactly but I have to change some things for non-symmetrical. will do it a bit later22:19
f-xso it is possible, but it may be messy22:20
@sonney2kmessy == avoid22:21
blackburnsonney2k: reported to ML22:22
f-xbut the parser/buffer are not linked with any features class.. how do they know what kind of features they're expected to read/store?22:23
@sonney2kf-x, there is one benefit when deriving from CFeatures - it could use the preprocessors22:23
f-xsonney2k: yes.. but it will derive from CFeatures when it derives from say CDotFeatures22:24
@sonney2kf-x, you can defintely construct a parser<T> as member variable22:24
@sonney2kso just using CStremingSipleFeatures<T> works just fine22:25
@sonney2kf-x, I am not sure that deriving from e.g. SimpleFeatures etc is a good idea22:26
@sonney2kI mean these feature objects assume that the number of examples is known22:26
@sonney2kand so what would happen if you apply them to an algorithM/22:27
f-xagreed.. it's probably easier to write the operations from scratch22:27
f-xthe algorithm would have to be changed a lot to consider the 'streaming' modifications22:27
f-x(if we apply SimpleFeatures to the algorithm)22:27
@sonney2kI would derive all the templated CStreaming*Features<T> from CFeatures22:27
f-xand write the functions separately?22:28
@sonney2kunderneath use your templated buffers/parsers (here we should really check that we don't dupllicate too much with what is available in the CFile thing - I would rather add code to that then having a new serparete interface)22:28
f-xi was thinking of somehow integrating with SimpleFeatures, StringFeatures etc and using the functions already present, but that's more problematic22:28
@sonney2khowever you will then have to convert all the online methods to use that interface22:29
f-xyes, the methods based on say CDotFeatures won't work22:30
f-xif we derive directly from CFeatures22:30
@sonney2kand I still don't see how one could do better then CStreamingDotFeatures and define all the op's in there again...22:30
f-xthe amount of work is probably the same even if we derive it from DotFeatures... anyhow most of the functions have to be redefined22:31
f-xthe only advantage was that the present algorithms would work (or at least accept as input parameters) with these features22:31
@sonney2kf-x, the problem I see is that e.g. LibSVM can work with dotfeatures22:31
@sonney2kbut not with any kind of stremaing features22:31
@sonney2kso most of the algorithms won't work...22:32
f-xunless we redefine them to work with streaming features22:33
@sonney2kthe only online methods we have in shogun are perceptron, sgd, liblinear, larank22:33
@sonney2kso modifying these to work with either CDotFeatures / CStreamingDotFeatures sounds much easier too me22:33
@sonney2kf-x, but for libsvm we don't even know any efficient online algorithm22:34
f-x so LibSVM isn't supposed to work with streaming features at all?22:34
f-xokay.. good22:34
@sonney2kf-x, I guess someone would first have to write a paper about it how to do it properly22:34
@sonney2kI am afraid though that this is not so easy22:35
@sonney2kkernel methods are not really suited for online learning22:35
f-xso for the time being our targets are perceptron, sgd, liblinear, larank and vw22:35
@sonney2kthese are all linear methods (ok larank might be able to use kernels)22:36
f-xi'm hoping the structure we're adopting now will be compatible with vw22:36
@sonney2kwhy not?22:37
@sonney2kin the end fw needs some vectorial input22:37
f-xi guess most methods just follow the input()->train()->predict() sequence22:38
f-xyou're right.. but i'll need john to help me out on exactly what should go into vw's "train" and "predict" functions22:38
f-xanyway, that comes a bit later22:38
f-xsonney2k: could we just finalize the inheritance? (just so i have some concrete record of it)22:39
@sonney2kto avoid any misunderstanding - could you please summarize what you would do now22:39
@sonney2kexactly :D22:39
f-xread my mind22:40
f-xerr.. StreamingFeatures derives from CFeatures first22:40
@sonney2kwell but only if you need streamingfeatures22:41
@sonney2kyou could aswell directly start with CStreamingStringFeatures<T> : public CFeatures22:41
f-xexactly what i was thinking..22:41
f-xplus it's difficult to have a StreamingFeatures without a type specified22:42
@sonney2kI would introduce a new feature property STREAMING22:42
@sonney2kcurrently we only have FP_DOT as property22:43
f-xhmm.. right22:43
@sonney2kf-x, well it could be used to limit your algorithm to streamingfeatures22:43
f-xmake my own property?22:43
f-xokay.. STREAMING22:44
@sonney2kbut on the other hand you could as well require CFeatures and check that the streaming property is set22:44
@sonney2kf-x, libshogun/features/FeatureTypes.h add it to EFeatureProperty22:44
@sonney2kthen call set_property(FP_DOT); in constructor22:45
@sonney2kthat's it22:45
f-xcool :)22:45
f-xso now i'm allowed to change the member functions and stuff right?22:45
f-x(not expecting to maintain compatibility with the current SimpleFeatures<T> since the algorithm must be changed too)22:45
@sonney2kyeah whatever streaming features fits most22:46
f-xgood, since it was a knotty problem with all that loopy inheritance22:46
@sonney2kf-x, if we really want SimpleFeatues<T> to use StreamingFeatures one could add a function to CSImpleFeatures<T>::obtain_from_streaming(CStreamingSimpleFeatures<T>* f)22:46
@sonney2kthis would then load all the features into memory and done22:47
@sonney2kthen all algo's would work again22:47
f-xgood idea22:47
@sonney2kactaully a good way to test things22:47
f-xso all online->batch would be possible22:47
@sonney2kshould give same results :D22:47
f-xand a reverse batch->online wouldn't be difficult22:47
f-xlooks interesting :)22:48
@sonney2kf-x, true even that22:48
@sonney2kso the only thing I am not too sure of now is whether CStreamingDotFeatures should derive from CFeatures or not22:49
@sonney2kI mean should CStreamingSimpleFeatures derive from CStreamingDotFeatures?22:50
@sonney2k(that is how it is done currently for non-streaming features022:50
f-xIt wouldn't be a problem, i think22:50
@sonney2kblackburn, thanks - looks good22:51
f-xi guess if we're using more features that use the dot operation, it might help to have a CStreamingDotFeatures class22:51
f-xas long as the inheritance is linear, things look fine22:52
@sonney2kf-x, I mean I would directly copy the interface of CDotFeatures22:52
@sonney2kbecause most of the online methods are linear ones and do benefit from dotfeatures quite a bit22:52
f-xcopy into CStreamingDotFeatures?22:52
@sonney2kyeah - if necessary adjust API22:53
@sonney2kand then when you modify e.g. SVMSGD you don't have much to do22:53
@sonney2kbecause the same functions are there22:53
f-xSVMSGD, online version, would be a different function though, right?22:55
f-xwith most of the code same22:55
f-xso the caller uses something like SVMSGD_Online() whatever for the online version and SVMSGD() for the batch version22:55
@sonney2kf-x, I would modify SVMSGD to accept either CDotFeatures or CStreamingDotFeatures22:57
f-xokay, overload?22:57
@sonney2kI am not sure yet - templated or overloaded - definitely no if else mess22:58
@sonney2kI guess overloaded22:59
f-xoverloaded is safer, i agree22:59
@sonney2kand encapsulate the functions that do add_dense_vec etc22:59
f-xin CStreamingSimpleFeatures23:01
@sonney2kI mean if you use templates then you could plug in CDotFeatures or CStreamingDotFeatures23:01
@sonney2kand the rest stays the same23:01
@sonney2kif not you will have to encapsulate all the functions that use the DotFeatures23:02
f-xi'm not sure if i'm totally clear with this.. even if i use templates, i'd still have to modify the train() method23:04
f-xbasically train() should train using one example, and repeated calls to train() would be required to train for the whole dataset23:05
f-xor a new function "train_one_example()" could be made and train() itself makes repeated calls to train_one_example() until all examples are used up23:05
@sonney2kf-x, true23:09
@sonney2keven the DotFeatures require an example inde23:10
@sonney2kso the online algorithm is very different23:10
f-xthe index should be removed, or should always be set to zero.. in effect, functioning as a dummy23:11
@sonney2kI mean you need to call the get_next_vector things only23:11
@sonney2k(in the online variant of sgd)23:12
@sonney2kso StreamingDotFeatures would not have any index23:12
f-xso basically this means modfiying the algorithm will not be a search-and-replace exercise :/23:13
f-xbut still it looks pretty doable23:14
f-xi guess this should be good enough for me to implement the SGD at least :)23:17
f-xthanks a lot, sonney2k.. things seem a lot clearer now23:17
@sonney2kf-x, so what do you think is reasonable for midterm?23:17
f-xwhat do you have in mind, sonney2k? :)23:18
@sonney2kI mean the long term plan for gsoc would probably be all the streaming feature types and converting all the algorithms23:18
f-x+ vw23:18
@sonney2kf-x, I am not sure what John would want you to do on the vw side23:18
f-xi mean vw for shogun23:18
f-xwhat's the most important feature type according to you?23:19
@sonney2kI mean you have 2.5 months full time - so it is possible I think23:19
f-xit's possible, i agree.. unless some big structural change comes up later and everything requires a whole rewrite... that's all i'm worried about23:20
@sonney2kI would say that with ascii based files SimpleFeatures and SparseFeatures are really easy to do23:20
@sonney2kf-x, I don't see that coming though23:20
@sonney2k(famous last words...)23:20
f-xit's a relief, nonetheless23:20
@sonney2kSo I think you should aim for getting simple and sparse streaming features to work together with dotfeatures23:21
@sonney2kand then SGD or so on top of it23:21
@sonney2kthis month23:22
f-xsounds pretty good..23:22
@sonney2kthen I would rather change more of the online algorithms (say liblinear)23:22
f-xi haven't seen much of the sparse features code, but shouldn't be that much of a problem, not that the structure is resolved23:22
f-x*now that the23:22
@sonney2kf-x, I mean in the end look at DataType.h23:23
@sonney2kall you need to do is return a SGSparseVector<T>23:23
@sonney2kit is basically index, value23:23
@sonney2kand all the dotfeatures code can be generalized from what you find in simplefeatures / sparsefeatures23:24
@sonney2kI would create some static functions in there that you could use in the streaming* variants23:24
@sonney2kso it should be very doable in 1-2 weeks for some simple ascii format23:24
f-xtrue, true23:25
@sonney2kf-x, the problem I see with all this i/o business is that shogun already has the CFile* interface23:26
@sonney2kand it would be best if you could utilize this somehow23:26
f-xor incorporate any new functions i make into CFile23:26
@sonney2kor derived files23:26
f-xwhat exactly do you want me to use in CFile?23:27
f-xCStreamingFile derives from it23:27
f-xand the built-in functions read the whole file23:27
@sonney2kf-x, just the API - it is perfectly fine to have StreamingFile23:29
@sonney2kand incrementally return the next vector when one calls get_float32_vector etc23:29
f-xyeah.. that makes sense23:30
f-xright now i use get_real_vector in parser.h which does the same i think23:30
@sonney2kf-x, I guess you should rename this then to CStreamingAsciiFile and implemnet the API functions23:31
@sonney2kand use these functions in your StreamingFeature classes23:31
f-xwill do. since 'StreamingFile' is actually a modification of AsciiFile.23:32
@sonney2kI guess the buffering is also only necessary for asciffiles?23:32
f-xwouldn't buffering be beneficial for binary files too?23:33
f-xi mean the parsing step would be simplified, but the example objects would be read and stored in the buffer in a similar fashion23:33
@sonney2kf-x,I am loosing track of all the buffers23:34
f-xlet's call this one the "ring" :)23:34
@sonney2kI mean for ascii we have an input buffer that just buffers what is in the raw file right?23:34
f-xcall it the I/O buffer23:34
@sonney2kand then we have a buffer for the examples that stores the parsed data right?23:35
f-xcalled a 'ring'23:35
@sonney2kso the ring is always necessary agreed23:35
@sonney2kthe i/o buffer too?23:35
f-xthe I/O buffer isn't implemented yet for AsciiFile23:35
@sonney2kI don't know23:35
f-xno I don't think the IO buffer would be necessary23:35
@sonney2kf-x, yeah but it is the getline ting23:35
f-xsince we can directly red one example at a time23:35
f-xyes, the getline thing is a simple substitute23:36
f-xit would be much faster if we read as much data as possible into the IO buffer, and then use getline on that23:36
@sonney2kf-x, I meant when you do getline with fread (without seeking)23:36
f-xso IO buffer must be copied from VW and made compatible23:37
@sonney2kfor binary it could only be that reading examples of low dimensionality would benefit from a buffer23:38
@sonney2kothewise fread is called very often...23:38
f-xi need to have a deeper look though, to be able to make a final statement on this23:38
@sonney2knot sure if that is really a problem though23:39
f-xbut most likely the buffer could be needed -- but only if it is speedy enough23:39
f-xno, not a major problem23:39
@sonney2kI mean I don't have such small examples in practice23:39
f-xoh.. ok. good23:39
f-xanyway it wouldn't hurt to assume for now that the buffer may be needed for binary too..23:40
@sonney2kso plan would be 1. put the fread based getline in asciifile 2. do the StreamingAsciffFile and use this getline 3. convert StreamingFeatures to be templated CStreamingSimpleFeatures and derived from CFeatures and make it use the StreamingFile API23:41
@sonney2k4. get OnlineSGD to work23:42
@sonney2kf-x, does that make sense?23:42
f-xsonney2k: it does, it does23:42
@sonney2kand for the buffering you borrow code from vw23:43
f-xexactly what i was about to ask23:43
@sonney2kit would be great to have a CVowpalWabbit soon in shogun though23:43
@sonney2kI gues23:43
f-xyeah.. that name has a nice ring to it :)23:43
@sonney2kI don't know if it is realistic to for midterm23:43
@sonney2kI mean you would totally have to port the algorithm to use shogun's dotfeatures23:44
f-xCVowpalWabbit? i guess a lot of discussion would be required to port that properly23:44
@sonney2kso that is sth you can only do with john giving you lots of hints23:44
blackburnhey what VW does? :D23:45
f-xthere are tons of optimizations in vw that may be difficult to fit into our structure23:45
@sonney2kf-x, in the end VW implements SGD with john specific tricks I guess23:45
@sonney2kblackburn, online SVm - like SGD23:45
blackburnah I see23:45
blackburnI just dimreduction redneck so don't know much about these svms :D23:46
f-xblackburn: redneck? by now you're an old veteran!23:47
blackburnI mean I'm dummy in SVMs :)23:47
@sonney2kf-x, I would suggest you try to do 1-3 next week23:48
@sonney2kplease please small patches whenevery you have sth finished23:48
@sonney2kotherwise I won't be able to review these easily23:48
f-xhow big is 'something' supposed to be?23:48
@sonney2k(bug chunks are hard to digest...)23:48
f-x"bug chunks" :P23:48
@sonney2kbig :D23:49
@sonney2kf-x, I mean if you do fread based getline in asciifile -> pull request23:49
@sonney2kif you write StremaingAsciiFIle -> pull request23:49
@sonney2kand so on23:50
@sonney2ksmall logical units23:50
f-xokay.. got it23:50
blackburnI've invented a game: we pull code with bugs and Soeren is guessing where it is23:50
@sonney2kblackburn, in the end I can only loose :`-(23:50
f-xblackburn: yeah, it's 5 vs. 123:51
@sonney2kf-x, so lets discuss again end of next week - and I hope to see plenty fo pull requests23:51
blackburnsonney2k: but you are 80 lvl coder :D you have chances23:51
@sonney2kif you have questions in the meantime ask per mail or chat23:51
f-xsonney2k: sure.. a pull request soon.23:52
f-xi guess i'll go to bed now.. thanks for the insight, sonney2k23:52
@sonney2kf-x, thanks for this nice discussion and I hope you will have some fun doing these things23:52
* sonney2k wonders why f-x always writes similar sentences :D23:53
f-xsonney2k: i'm sure i will :) now things seem much simpler23:53
f-xbbye, sonney2k and blackburn23:53
blackburnf-x: are you robot? what is an integral of cot(x)? :D23:54
blackburnbye :)23:54
f-xblackburn: don't give me bad dreams.. i'm trying to go to bed now :)23:54
-!- f-x [~user@] has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]23:55
blackburnsonney2k: how are your family?23:56
* sonney2k feels exhausted23:56
@sonney2keveryone asleep23:56
@sonney2khealthy and growing ...23:56
blackburnnice :)23:56
@sonney2kwent swimming / to the zoo23:56
@sonney2kwas a lot of fun I can tell23:56
blackburnI have seen you live near lake?23:57
@sonney2kmy daughter was pretty excited about a pelican trying to chase him...23:57
@sonney2k(these are running around freely in the zoo 'tierpark')23:58
blackburnyou are happy: have nice places here :)23:58
blackburn - place where I live :D23:59
--- Log closed Sun Jun 12 00:00:16 2011