[08:13:12 CST(-0600)] <heidiv> jhung was a decision made for http://issues.fluidproject.org/browse/FLUID-4859 ?

[08:16:27 CST(-0600)] <jhung> let me check heidiv

[08:17:31 CST(-0600)] <heidiv> maybe i'll take a look at this blocker first http://issues.fluidproject.org/browse/FLUID-4901

[08:17:57 CST(-0600)] <jhung> Yeah FLUID-4859 isn't one of our blockers right now.

[08:18:29 CST(-0600)] <jhung> FLUID-4901 sounds good heidiv

[08:18:43 CST(-0600)] <heidiv> cool

[08:23:23 CST(-0600)] <Justin_o> heidiv: i'm going to look at your pull request for FLUID-4889 now..

[08:23:36 CST(-0600)] <Justin_o> is it only for FF?

[08:23:58 CST(-0600)] <heidiv> Justin_o FF on mac/win but also minor minor tweak for webkit - it was disappearing on my laptop

[08:24:39 CST(-0600)] <Justin_o> heidiv: cool.. thanks..

[08:30:30 CST(-0600)] <Justin_o> heidiv: okay.. took a look at things.. is it possible to make it fill up the entire screen when the transcripts aren't there.. also chrome looks a bit off

[08:30:54 CST(-0600)] <heidiv> Justin_o i left chrome as is… that's how it was before.

[08:31:26 CST(-0600)] <heidiv> Justin_o we could programmatically make it shift when transcripts aren't there, but it didn't seem within the scope for now

[08:31:48 CST(-0600)] <Justin_o> heidiv: would it be possible to improve chrome a bit

[08:31:58 CST(-0600)] <Justin_o> heidiv: safari looks great by the way

[08:32:05 CST(-0600)] <heidiv> ok good

[08:32:36 CST(-0600)] <heidiv> Justin_o are you on laptop for monitor or both?

[08:35:09 CST(-0600)] <Justin_o> heidiv: trying it on both

[08:35:47 CST(-0600)] <heidiv> Justin_o i could take a look at tweaking chrome maybe in another jira? finicky cos it uses the same css as safari

[08:36:05 CST(-0600)] <Justin_o> just talked to jhung, for now we don't need to worry about using up the whole screen when there are no transcripts

[08:36:09 CST(-0600)] <Justin_o> so just the chrome issue

[08:37:02 CST(-0600)] <heidiv> k i'll take a quick look to see if chrome can be improved easily.

[08:37:16 CST(-0600)] <heidiv> it's functional and not terrible, which is good

[08:37:18 CST(-0600)] <heidiv>

[09:37:48 CST(-0600)] <colinclark> michelled and yzen1: I just responded to the thread with evgeni about repositories and the Common Terms Registry

[09:38:02 CST(-0600)] <colinclark> or the REGISTRY as Gregg and yzen1 like to shout it

[09:38:12 CST(-0600)] <michelled>

[09:38:16 CST(-0600)] <colinclark> I don't know how much extra work I'm causing...

[09:38:33 CST(-0600)] <colinclark> but the Registry really is a separate module from the "Real Time Framework"

[09:38:53 CST(-0600)] <colinclark> My sense is that there's a convenience in having it co-located with the rest of the universal repository...

[09:39:06 CST(-0600)] <colinclark> likely due to the fact that we don't have our shared infrastructure factored quite right.

[09:39:37 CST(-0600)] <colinclark> My impression, and definitely correct me if I'm wrong, is that there is a kernel of code in Universal that is, in fact, analogous to what we used to call "Kettle"

[09:41:10 CST(-0600)] <colinclark> michelled and yzen1: Is this your impression as well?

[09:41:51 CST(-0600)] <colinclark> And what kinds of things might we need to do to extract this so that it's easy to spin up new Node.js/Kettle-based codebases without having to cut and paste boilerplate from Universal?

[09:42:22 CST(-0600)] <michelled> (jura) colinclark I think if universal is used as an external repo as it is in the REGISTRY it should probably be used as a proper node_module for now

[09:42:39 CST(-0600)] <colinclark> The Island of Jura!

[09:42:47 CST(-0600)] <michelled> instead of copy and past of bits and pieces

[09:43:01 CST(-0600)] <colinclark> michelled: I don't fully understand

[09:43:24 CST(-0600)] <colinclark> I guess I should look at what Evgeni's doing more closely

[09:43:25 CST(-0600)] <michelled> colinclark: if used as a node module, all the things registry needs to be bootstrapped would be then looked up by Node itself

[09:43:49 CST(-0600)] <michelled> that's Yura by the way

[09:44:21 CST(-0600)] <colinclark> no wonder I'm confused

[09:44:26 CST(-0600)] <michelled> ha

[09:44:32 CST(-0600)] <michelled> ^that was Michelle

[09:44:54 CST(-0600)] <colinclark> the terse and the elliptical

[09:45:23 CST(-0600)] <colinclark> How is universal used in the Registry?

[09:46:02 CST(-0600)] <colinclark> I guess there's really not a ton here, nor is there even much boilerplate

[09:46:11 CST(-0600)] <colinclark> so why did you want the Registry to be part of Universla?

[09:46:19 CST(-0600)] <michelled> colinclark: i guess what i m trying to say is that it is fine to use it as a separate repo but in somewhat similar fashion to linux or windows (as a node_module). Currently it's just merged together

[09:46:47 CST(-0600)] <michelled> colinclark: i did not realize it was a separate thing, i thought for some reason it is just one of many architecture components

[09:47:25 CST(-0600)] <colinclark> I always chafed against making much of a distinction between physical deployment of components with the "Real Time Framework"

[09:47:58 CST(-0600)] <colinclark> But I guess there's an issue of "lifetime," in part, here

[09:48:14 CST(-0600)] <colinclark> So I guess, to think aloud a little bit, we've got a few different kinds of things

[09:48:44 CST(-0600)] <colinclark> First, a bundle of stuff that represents "the personalization process"

[09:49:02 CST(-0600)] <colinclark> Which pretty much consists of whatever's in the architecture diagram I drew

[09:49:20 CST(-0600)] <colinclark> and is the union of Universal + the platform-specific repositories

[09:49:43 CST(-0600)] <colinclark> Within that, though, there are two pieces that don't fit 100% clearly

[09:49:57 CST(-0600)] <colinclark> The Preferences Server and the Solutions Registry

[09:50:28 CST(-0600)] <michelled> ontology ?

[09:50:48 CST(-0600)] <colinclark> Yeah, the Ontology Server, too

[09:50:52 CST(-0600)] <colinclark> good point

[09:51:02 CST(-0600)] <colinclark> Some aspect of this difference, we've argued, is largely just "coincidental;" namely, location

[09:51:07 CST(-0600)] <colinclark> that sentence probably didn't make sense

[09:51:30 CST(-0600)] <michelled> it does i think

[09:51:39 CST(-0600)] <colinclark> The point being that, to use your shorthand, the PS, SR, and OS are part of the "real time" workflow of the GPII

[09:51:43 CST(-0600)] <colinclark> but likely physically separate

[09:51:55 CST(-0600)] <colinclark> I guess it's this notion of "real time" that, for once, is pretty useful

[09:52:20 CST(-0600)] <colinclark> We use it to define a boundary of highly optimized code which may be regularly consulted as part of the personalization process

[09:52:25 CST(-0600)] <colinclark> by everyone who is personalizing

[09:52:37 CST(-0600)] <colinclark> So that boundary, I think, is the key one between the Registry and everything else

[09:52:57 CST(-0600)] <colinclark> It's more a source of "reference information" rather than a source of real-time data for the personalization process

[09:53:34 CST(-0600)] <colinclark> I guess, still, conceptually the PS, SR, and OS are also a bit different from most of the other things in Universal

[09:53:49 CST(-0600)] <colinclark> which are particularly focused on "doing stuff"

[09:54:36 CST(-0600)] <colinclark> Anyways, I guess it's clear that there really isn't a solid distinction between these things, and there will be less of one as we move forward on the notion of a "flow manager in the cloud," as we were dreaming about for UIO the other week

[09:55:05 CST(-0600)] <colinclark> So michelled/jura, one question I have, then, is what benefit we get from even co-located the PS, SR, and OS within the same repository?

[09:55:49 CST(-0600)] <colinclark> I think there is probably a good rationale for it--I'm assuming it's the point that these things are all necessary in order to run the real-time system

[09:55:59 CST(-0600)] <colinclark> but are there other reasons?

[09:57:39 CST(-0600)] <michelled> colinclark: not really, i think partially the "necessary to run" also means that they use the same stuff to run themselves

[09:57:57 CST(-0600)] <colinclark> yes

[09:57:59 CST(-0600)] <colinclark> that makes sense

[09:58:05 CST(-0600)] <colinclark> what is that "same stuff," specifically?

[09:58:08 CST(-0600)] <michelled> colinclark: (fish here) I think for me it's really just a habit I've formed of having everything I need in one repo

[09:58:16 CST(-0600)] <michelled> but I don't think it's necessary

[09:58:48 CST(-0600)] <michelled> colinclark: (jura) gpii framework really is the only dependency + the external node modules

[09:58:56 CST(-0600)] <colinclark> ah, ok

[09:59:17 CST(-0600)] <michelled> colinclark: which we are hoping to get rid of physically in the repo

[09:59:20 CST(-0600)] <colinclark> the "everything in one repo" argument is sort of okay, in that I'm fine with co-locating things for convenience

[09:59:54 CST(-0600)] <michelled> (fish) I'm not sure it is more convenient - it's just "what we've always done"

[10:00:00 CST(-0600)] <colinclark> the question is, michelled, whether when, hypothetically, someone like avtar comes along and deploys the system on his server, whether he gets annoyed with all the extra cruft that comes along with it

[10:00:17 CST(-0600)] <colinclark> michelled (fish): It is?

[10:00:25 CST(-0600)] <michelled> (jura) if you remember originally they were separated and we had a git submodule for universal in each repo

[10:01:02 CST(-0600)] <colinclark> ah yes

[10:01:05 CST(-0600)] <michelled> (fish) why did they get merged into one repo?

[10:01:12 CST(-0600)] <colinclark> and that was distinctly inconvenience

[10:01:21 CST(-0600)] <colinclark> I can only imagine this the oddest pair programming session...

[10:01:41 CST(-0600)] <colinclark> while you each talk to each other by typing into a chat room on the same keyboard

[10:02:08 CST(-0600)] <michelled> well the whole submodule thing is not the right approach, i think it should've been an npm dependency and not the git submodule

[10:02:39 CST(-0600)] <colinclark> michelled (jura): elaborate?

[10:02:44 CST(-0600)] <michelled> colinclark: that's also why we have this awkward structure with 2 sets of node_modules in universal

[10:03:19 CST(-0600)] <colinclark> right, yes

[10:03:26 CST(-0600)] <michelled> well the reason we had submodule was because npm did not support git repo as a source at that time, and that was the only way to get the code checked out

[10:03:40 CST(-0600)] <michelled> without publishing universal to npm

[10:04:08 CST(-0600)] <michelled> nowit's unnesessary

[10:04:23 CST(-0600)] <colinclark> I guess npm doesn't quite solve the development use case, though, does it?

[10:04:45 CST(-0600)] <michelled> can you give an example ?

[10:04:56 CST(-0600)] <colinclark> In that, if I want to hack on a codebase that comprises multiple repositories/modules, I still have to go clone them all

[10:05:08 CST(-0600)] <colinclark> Well, I am still relatively new to npm, so perhaps I'm mistaken

[10:05:33 CST(-0600)] <colinclark> but I guess npm module dependencies are great, because you can just "npm install" one thing, and several other things will come along with it

[10:05:57 CST(-0600)] <michelled> colinclark: yes, i think that's what people expect now yes

[10:05:58 CST(-0600)] <colinclark> But let's say I wanted to hack on, at the same time, both the Flow Manager and the Preferences Server...

[10:06:26 CST(-0600)] <colinclark> wouldn't you still have the problem of assembling a set of git repositories laid out in the correct directory structure, etc?

[10:06:42 CST(-0600)] <colinclark> or rather, wouldn't I?

[10:06:44 CST(-0600)] <michelled> (fish) does one depend on the other?

[10:07:01 CST(-0600)] <colinclark> one what?

[10:07:18 CST(-0600)] <michelled> I guess what I actually want to know is why you would want to hack on both at the same time

[10:07:29 CST(-0600)] <michelled> I was thinking of the case of VP + Captionator

[10:07:43 CST(-0600)] <colinclark> right

[10:07:45 CST(-0600)] <michelled> when I want to make a change to Captionator, I check out that repo, work on it and push

[10:07:50 CST(-0600)] <michelled> then I pull it down into VP

[10:07:53 CST(-0600)] <michelled> and work there

[10:08:02 CST(-0600)] <michelled> that feels like a natural workflow

[10:08:30 CST(-0600)] <colinclark> That assumes that you're working on a discrete problem in each repository

[10:08:42 CST(-0600)] <colinclark> "fix the problem in captionator, push it, then go work on the video player"

[10:09:08 CST(-0600)] <colinclark> as opposed to, "I have this weird problem in the Video Player that I think is related to Captionator, and I have to change something in both places"

[10:09:42 CST(-0600)] <michelled> i think it;s not applicable with flow manager and pref server i think

[10:10:13 CST(-0600)] <michelled> these components interact very differently with each other

[10:10:30 CST(-0600)] <colinclark> only until the requirements change, perhaps

[10:10:36 CST(-0600)] <colinclark> anyway

[10:10:44 CST(-0600)] <colinclark> still...

[10:10:49 CST(-0600)] <colinclark> so, let's say I'm new to GPII

[10:10:55 CST(-0600)] <michelled> but yes the problem of deploying things together is a problem

[10:11:00 CST(-0600)] <colinclark> and I want to hack on a new settings handler and test it out on my linux box

[10:11:11 CST(-0600)] <michelled> the only way to do it without any extra work would be then installing it globally ?

[10:11:30 CST(-0600)] <colinclark> maybe it's a "plist settings handler", so it will go into universal

[10:11:56 CST(-0600)] <colinclark> I guess if all the dependencies are sourced via npm, I'd have to check out a repository and then do a bunch of npm installs?

[10:11:58 CST(-0600)] <colinclark> or something?

[10:12:33 CST(-0600)] <michelled> yes

[10:12:38 CST(-0600)] <colinclark> yeah

[10:12:39 CST(-0600)] <colinclark> ok

[10:12:58 CST(-0600)] <colinclark> So we don't really have a workflow that works very well, for separate modules

[10:13:07 CST(-0600)] <michelled> well no

[10:13:09 CST(-0600)] <colinclark> remind me again why Git submodules are unsatisfying to you?

[10:13:33 CST(-0600)] <michelled> they are not it depends on where you want to use them and for what

[10:13:55 CST(-0600)] <michelled> i was giving an example of using npm over submodules to deal with node_modules

[10:14:04 CST(-0600)] <colinclark> yup, i know what you mean

[10:14:37 CST(-0600)] <colinclark> I'm just trying to think if submodules and npm dependencies are mutually exclusive

[10:14:43 CST(-0600)] <colinclark> and I guess they aren't

[10:15:52 CST(-0600)] <michelled> so how do we address the issue with the REGISTRY though ?

[10:16:56 CST(-0600)] <colinclark> Well, the REGISTRY is interesting

[10:17:05 CST(-0600)] <colinclark> I will, for now, argue that it really is different

[10:17:15 CST(-0600)] <colinclark> in that you don't need it to run the Flow Manager

[10:17:24 CST(-0600)] <colinclark> it doesn't participate in any part of the "real time" flow

[10:17:47 CST(-0600)] <colinclark> So it seems sensible to have it as a separate repository...

[10:17:51 CST(-0600)] <michelled> right

[10:17:58 CST(-0600)] <colinclark> the question is, what ends up having to be duplicated?

[10:18:03 CST(-0600)] <michelled> yes

[10:18:11 CST(-0600)] <colinclark> He essentially has the exact same node_modules directory as universal, right?

[10:18:20 CST(-0600)] <michelled> almost

[10:18:26 CST(-0600)] <michelled> it's more of a mix of linux and universal

[10:18:44 CST(-0600)] <colinclark> interesting

[10:18:46 CST(-0600)] <colinclark> why the mix?

[10:18:48 CST(-0600)] <michelled> like he has things like start.js which we mainly use to start a platform specific deployment

[10:19:21 CST(-0600)] <michelled> in linux it's called gpii.js

[10:19:29 CST(-0600)] <michelled> or windows

[10:19:32 CST(-0600)] <colinclark> ok

[10:19:36 CST(-0600)] <colinclark> Let's break this down

[10:19:52 CST(-0600)] <colinclark> https://github.com/tsakov/common-terms-registry/tree/master/node_modules

[10:20:08 CST(-0600)] <colinclark> https://github.com/GPII/universal/tree/master/node_modules

[10:20:20 CST(-0600)] <colinclark> They're nearly identical

[10:20:32 CST(-0600)] <colinclark> to the point, in fact, where he's got more modules than he actually needs

[10:20:45 CST(-0600)] <michelled> they are not though

[10:20:54 CST(-0600)] <colinclark> i.e. the xml-mapping and semver dependencies

[10:20:55 CST(-0600)] <michelled> he has

[10:21:11 CST(-0600)] <michelled> universal/node_modules and universal/gpii/node_modiles mixed in together

[10:21:19 CST(-0600)] <colinclark> right

[10:21:46 CST(-0600)] <colinclark> So, the way I see it-correct me if I'm wrong-he's really trying to express a dependency on "Kettle," no?

[10:22:14 CST(-0600)] <colinclark> His way of doing that was simply to assemble everything he saw that seemed to fit--i.e. this "gpiiFramework" thing, plus everything it apparently needed?

[10:22:17 CST(-0600)] <colinclark> maybe I'm wrong

[10:22:31 CST(-0600)] <michelled> yes correct

[10:22:44 CST(-0600)] <colinclark> ok, cool

[10:23:14 CST(-0600)] <colinclark> so in an ideal sense, one imagines that he would have rather just done a "npm install kettle" and received everything he needed

[10:23:22 CST(-0600)] <colinclark> What stops him, today, from actually doing that?

[10:23:32 CST(-0600)] <michelled> exactly

[10:23:45 CST(-0600)] <colinclark> Ooh

[10:23:49 CST(-0600)] <michelled> on in other words at this point it is npm install universal no ?

[10:23:49 CST(-0600)] <colinclark> I think I must have made a point

[10:24:00 CST(-0600)] <michelled> nothing stops him

[10:24:15 CST(-0600)] <colinclark> but doesn't he get a lot more if he depends on all of universal?

[10:24:24 CST(-0600)] <michelled> he does but who cares

[10:24:36 CST(-0600)] <colinclark> lol

[10:24:43 CST(-0600)] <michelled> ^ that was michelled

[10:24:54 CST(-0600)] <michelled> no it wasn't!

[10:24:57 CST(-0600)] <michelled>

[10:25:01 CST(-0600)] <colinclark> Well, for fun, let's pretend I care

[10:25:31 CST(-0600)] <michelled> jura is wondering why it matters

[10:25:49 CST(-0600)] <michelled> I guess when we are talking server side, stuff can just be ignored

[10:25:59 CST(-0600)] <michelled> it's not like we are shipping it to the client

[10:26:11 CST(-0600)] <colinclark> oh dear

[10:26:17 CST(-0600)] <michelled> that was not jura

[10:26:18 CST(-0600)] <colinclark> web developers

[10:26:21 CST(-0600)] <avtar>

[10:26:29 CST(-0600)] <jessm> i'm loving this

[10:26:29 CST(-0600)] <colinclark> thank you, avtar!

[10:26:38 CST(-0600)] <avtar> depends on how much stuff

[10:27:03 CST(-0600)] <colinclark> michelled (jura): let's pretend avtar doesn't have half a petabyte of storage to share with you

[10:27:14 CST(-0600)] <colinclark> and he'll only give you a 10 MB VM to deploy your masterpiece on

[10:27:20 CST(-0600)] <michelled> of javascripts ?

[10:27:37 CST(-0600)] <michelled> well ok

[10:27:57 CST(-0600)] <colinclark> Not to mention the whole issue, of, say, complexity and inability to understand what your program actually consists of

[10:27:59 CST(-0600)] <michelled> so one of the ways to approach it is to modularize it

[10:28:08 CST(-0600)] <colinclark> or the risk that unrelated code ends up getting RUN inadvertantly

[10:28:10 CST(-0600)] <michelled> since there;s a clear thing that universal and REGISTRY use

[10:28:12 CST(-0600)] <colinclark> etc etc

[10:28:33 CST(-0600)] <michelled> such as gpiiFramework + external_modules

[10:29:03 CST(-0600)] <colinclark> right

[10:29:14 CST(-0600)] <michelled> in other words kettle

[10:29:15 CST(-0600)] <colinclark> a.k.a "Kettle and its associated dependencies"

[10:29:17 CST(-0600)] <colinclark> yep

[10:29:20 CST(-0600)] <michelled> i was first

[10:29:22 CST(-0600)] <michelled>

[10:29:42 CST(-0600)] <colinclark> lol

[10:30:08 CST(-0600)] <avtar> "or the risk that unrelated code ends up getting RUN inadvertantly"

[10:30:08 CST(-0600)] <colinclark> ok, so, let's hypothetically say that we should just go ahead and make Kettle a thing

[10:30:13 CST(-0600)] <avtar> colinclark: so far that hasn't been an issue

[10:30:26 CST(-0600)] <avtar> but that's because i have a yura at my disposal

[10:30:31 CST(-0600)] <colinclark> lol

[10:30:33 CST(-0600)] <avtar> not sure if everyone will have a yura

[10:30:35 CST(-0600)] <avtar> everyone should

[10:30:39 CST(-0600)] <colinclark> i agree

[10:30:48 CST(-0600)] <avtar> brb, call

[10:30:56 CST(-0600)] <michelled> it also comes in a pocket version

[10:30:58 CST(-0600)] <colinclark> I'm hoping we can help mitigate the cost of yura-less-ness for others

[10:31:02 CST(-0600)] <colinclark> it's all about inclusion

[10:31:24 CST(-0600)] <michelled> well i feel like it might be time to do that, colinclark ?

[10:31:32 CST(-0600)] <colinclark> ok, let me get my headset

[10:31:52 CST(-0600)] <colinclark> anyone else is welcome to join

[10:32:03 CST(-0600)] <colinclark> though it will be a lot less fun trying to tell jura and fish apart

[10:32:19 CST(-0600)] <jessm> keep at it y'all – everyone else >> standup

[10:33:04 CST(-0600)] <colinclark> somehow i managed to convince myself that you were asking for a call, michelled

[10:33:12 CST(-0600)] <colinclark> but as i re-read things, i realize i am insane

[10:33:28 CST(-0600)] <colinclark> so, yeah, i'm thinking it might be time too, michelleds

[10:33:49 CST(-0600)] <colinclark> but the obvious question is, how much work will it be and how much impact will have?

[10:55:00 CST(-0600)] <colinclark> michelled(s): are you still around

[10:55:09 CST(-0600)] <colinclark> I guess we have our GPII meeting shortly

[10:55:10 CST(-0600)] <yzen1> colinclark: hi

[10:55:25 CST(-0600)] <yzen> i just realized that was the actual message of your email

[10:55:31 CST(-0600)] <colinclark>

[10:55:45 CST(-0600)] <colinclark> I wanted to make sure I was even thinking clearly

[10:55:55 CST(-0600)] <colinclark> so that was the message, but I was asking you guys if it made sense as the message

[10:56:50 CST(-0600)] <yzen> colinclark: ya by talking through it helped a lot. I think this is the sort of thing that needed to come up for us to go ahead

[10:57:39 CST(-0600)] <colinclark> yeah, that's what I was hoping

[11:03:30 CST(-0600)] <colinclark> yzen, michelled, evgeni. Bosmon: I'm thinking that Kasper may be tied up with the review preparation meeting today in Luxembourg

[11:04:02 CST(-0600)] <colinclark> so maybe if we don't hear from him in 10 minutes or so, we'll do quick updates here in the channel and then get back to work?

[11:05:02 CST(-0600)] <yzen> colinclark: sounds good

[11:12:17 CST(-0600)] <michelled> colinclark: is kasper_ the only organizer for this meeting?

[11:12:27 CST(-0600)] <colinclark> yeah, he's got the credentials

[11:12:35 CST(-0600)] <colinclark> as I say, I think we're fine to do some quick updates here

[11:12:52 CST(-0600)] <michelled> shall we then?

[11:12:58 CST(-0600)] <colinclark> yes!

[11:13:58 CST(-0600)] <colinclark> go for it, michelled

[11:14:30 CST(-0600)] <michelled> ok, I've been pairing up with yzen. We are working on the GPII renderer branch that Bosmon has reviewed

[11:14:45 CST(-0600)] <michelled> it's really great - yzen is giving me a code tour and some background information

[11:14:54 CST(-0600)] <michelled> that's about it for me

[11:14:56 CST(-0600)] <colinclark> cool

[11:15:08 CST(-0600)] <colinclark> what's your next step with it, fish?

[11:15:31 CST(-0600)] <colinclark> and what specific things need to be done before evgeni can use it?

[11:15:34 CST(-0600)] <michelled> we are converting some of the tests to browser tests

[11:16:32 CST(-0600)] <michelled> then we will get them passing again - currently there is an issue with the message source being resolved twice in the renderer code

[11:16:43 CST(-0600)] <michelled> I'm not sure what the next steps are past that

[11:16:52 CST(-0600)] <michelled> yzen could probably fill that in

[11:17:43 CST(-0600)] <yzen> yzen: i guess i can follow michelled

[11:18:29 CST(-0600)] <yzen> we d need to take a look at some test cases for node as well that would use the new grade to write responses to the client.

[11:18:48 CST(-0600)] <yzen> also i can probably take ok the separation of kettle work as well

[11:19:45 CST(-0600)] <colinclark> i was thinking it might be something to work on with michelled

[11:19:49 CST(-0600)] <colinclark> up to you guys, of course

[11:19:54 CST(-0600)] <colinclark> but it seems to fit into that whole sphere of work

[11:20:15 CST(-0600)] <yzen> colinclark: definitely

[11:20:25 CST(-0600)] <colinclark> any other updates, yzen?

[11:20:40 CST(-0600)] <yzen> no that's about it i think

[11:22:32 CST(-0600)] <colinclark> ok

[11:22:43 CST(-0600)] <colinclark> My update is fairly short again...

[11:23:22 CST(-0600)] <colinclark> I've spend quite a bit of time over the past week or so with jessm and the design team, helping to describe the technical aspects of Cloud4all

[11:23:47 CST(-0600)] <colinclark> so that they can continue to work on designs for the Personal Control Panel and to collaborate with Fraunhofer and others on the Preferences Management Tool

[11:25:43 CST(-0600)] <colinclark> I think we'll probably have some of them join one of our architecture meetings to talk a little bit about where the PCP designs are headed, once they've had some time to work on it

[11:26:03 CST(-0600)] <colinclark> We're trying to make sure that we've got an overarching view of preferences editing across our various spaces and contexts

[11:27:33 CST(-0600)] <colinclark> and then there are pairs working on designs for UIO, the PCP, and the PMT

[11:27:40 CST(-0600)] <colinclark> hopefully I've got that right, jessm and jvass

[11:28:13 CST(-0600)] <colinclark> Anyway, beyond that, there's the issue michelled and yzen mentioned of modularizing our code so that evgeni can issue a single npm dependency on our server-side framework

[11:28:20 CST(-0600)] <colinclark> and QA testing, which I have to admit I've done a terrible job of

[11:28:24 CST(-0600)] <colinclark> I got so confused

[11:28:36 CST(-0600)] <colinclark> found a number of apparent issues on Windows XP, so I'll try to finish that today

[11:29:31 CST(-0600)] <colinclark> Last night I had a very interesting conversation with Bosmon about types in programming languages and how our grades relate to them.

[11:30:01 CST(-0600)] <colinclark> It brought up this book by Ben Pierce, who also worked on Boomerang, our main precedent for "lensing" with the model transformation system: http://www.amazon.ca/gp/product/0262162091/ref=ox_sc_act_title_2?ie=UTF8&psc=1&smid=A3DWYIK6Y9EEQB

[11:30:30 CST(-0600)] <colinclark> Looks like a good read once I finish up with articles about the Epistemology of Cultural Things

[11:30:37 CST(-0600)] <colinclark> Anyway, I think that's about it for me

[11:30:56 CST(-0600)] <colinclark> One thing we'll need to do at the next meeting is to go through all our QA reports and determine what, if anything, needs to get fixed

[11:31:03 CST(-0600)] <colinclark> and then we should be able to unfreeze the codebase

[11:32:49 CST(-0600)] <michelled> colinclark: what do you mean by lensing?

[11:33:23 CST(-0600)] <colinclark> The term, I think, is Benjamin Pierce's

[11:33:46 CST(-0600)] <colinclark> You'll want to look at Boomerang, his "bidirectional programming language for textual data"

[11:33:48 CST(-0600)] <colinclark> http://www.seas.upenn.edu/~harmony/

[11:34:04 CST(-0600)] <colinclark> This manual is helpful: http://www.seas.upenn.edu/~harmony/manual.pdf

[11:34:25 CST(-0600)] <colinclark> If you skip down to page three, he defines lensing

[11:34:54 CST(-0600)] <colinclark> "Of course, we are not interested in just any transformations that map back and forth between data—we want the two directions of the transformation to work together in some reasonable way. Boomerang programs describe a certain class of well-behaved bidirectional transformations that we call lenses."

[11:35:08 CST(-0600)] <colinclark> The diagram at the top of page six takes a bit to understand

[11:35:36 CST(-0600)] <colinclark> but you can roughly see that there's a "lens" that represents a transformation to and from a different "format"

[11:35:43 CST(-0600)] <colinclark> just like our Model Transformations

[11:36:16 CST(-0600)] <michelled> cool, thanks for explaining

[11:36:19 CST(-0600)] <colinclark> Interesting is the fact that there are actually four boxes--two each for "source" and "view"

[11:36:42 CST(-0600)] <colinclark> which suggests that to do bidirectional transformations, you actually need to store some state as an artifact of the transformation

[11:37:13 CST(-0600)] <colinclark> We don't quite have support for that yet

[11:37:37 CST(-0600)] <colinclark> but this diagram and lens metaphor is a primary inspiration for transformation

[11:38:43 CST(-0600)] <colinclark> yzen: This quote from the article seems to illustrate our concern with the low-level conditional syntax that was originally proposed for GPII quite nicely:

[11:38:53 CST(-0600)] <colinclark> "Of course, programming with low-level combinators alone would be tedious and repetitive; we don’t do this."

[11:39:33 CST(-0600)] <colinclark> but misses the point about meaningful user semantics, rather than just "expressive programming power"

[11:39:36 CST(-0600)] <colinclark> anyway, i'm rambling now

[12:10:36 CST(-0600)] <jessm> colinclark: re ^ yes, exactly re: design work. in fact today something came up in chatting about a design that may need a technical answer from one of you, so it does feel like the right time to starting chatting together

[12:11:13 CST(-0600)] <colinclark> ok

[13:51:46 CST(-0600)] <anastasiac> fluid-everyone: does anyone want to join the PHP community workshop?

[14:15:22 CST(-0600)] <cindyli> http://10.4.41.160/php_overview/login.php

[14:16:51 CST(-0600)] <cindyli> https://github.com/cindyli/php_overview/

[14:23:24 CST(-0600)] <alexn> http://10.4.41.160/php_overview/phpinfo.php

[14:45:53 CST(-0600)] <anastasiac> https://github.com/acheetham/infusion-videoPlayer-wp-plugin/blob/IDI-104/infusion_videoPlayer.php

[14:48:37 CST(-0600)] <cindyli> http://php.net/manual/en/language.oop5.static.php

[14:55:55 CST(-0600)] <Justin_o> colinclark, Bosmon: do you guys have anything you'd like to cover or see covered in a future community meeting

[14:56:46 CST(-0600)] <colinclark> Nothing in particular

[14:57:44 CST(-0600)] <Bosmon> Perhaps we had a topic of "WHAT ARE MONADDS" vaguely on the table for some point? : P

[14:59:24 CST(-0600)] <Bosmon> We could talk about Deferreds/Promises/MONADDS etc. and "what they mean to us"

[14:59:51 CST(-0600)] <Bosmon> There's an interesting JIRA related to this that was raised by a problem of anastasiac's recently

[14:59:52 CST(-0600)] <Bosmon> http://issues.fluidproject.org/browse/FLUID-4883

[15:00:03 CST(-0600)] <colinclark> that would be interesting

[15:29:28 CST(-0600)] <cindyli> hi, Bosmon

[15:29:39 CST(-0600)] <Bosmon> cindyli!

[15:29:52 CST(-0600)] <cindyli> regarding ur comment on my pull request: "If these two special cases are only necessary for youTube videos, they should go into a separate body of code and not pollute the main logic. Is it possible to detect this case and issue a demands blocks with a dedicated event handler?"

[15:30:15 CST(-0600)] <Bosmon> Yes

[15:30:58 CST(-0600)] <cindyli> Bosmon: I understand it mean to use a different context for youtube in demands block to hook up a seperate handler, is that right?

[15:31:17 CST(-0600)] <Bosmon> cindyli - that's right

[15:31:20 CST(-0600)] <Bosmon> Does that seem possible?

[15:31:35 CST(-0600)] <cindyli> that's what i'd like to discuss about

[15:31:37 CST(-0600)] <Bosmon> Can you think of a straightforward and reliable way of detecting the youTube case?

[15:32:04 CST(-0600)] <cindyli> ya, not reliable enough

[15:32:22 CST(-0600)] <cindyli> the detection is from our so far discovery on the event firing

[15:32:51 CST(-0600)] <cindyli> the other question is that the only way I know of to create a different context is to register into static enviroment which would affect globally

[15:32:52 CST(-0600)] <Bosmon> That's fascinating...

[15:33:00 CST(-0600)] <Bosmon> Why can't we detect it from our configuration?

[15:33:31 CST(-0600)] <cindyli> i think the issue is not really with youtube. the root is about flash

[15:33:32 CST(-0600)] <Bosmon> cindyli - the context can also be applied to the root component of the VideoPlayer component tree

[15:33:44 CST(-0600)] <cindyli> oh, good to know. how?

[15:33:45 CST(-0600)] <Bosmon> THat would be the appropriate place for it, since it is only scoped to this videoPlayer

[15:33:49 CST(-0600)] <Bosmon> Just put it there

[15:34:05 CST(-0600)] <Bosmon> You could use a "typeFount" to do it declaratively

[15:34:14 CST(-0600)] <Bosmon> It all depends on how the detection is meant to work

[15:34:34 CST(-0600)] <Bosmon> So what other cases than youTube are there?

[15:35:40 CST(-0600)] <cindyli> Bosmon: i'm not sure at this point. Even though I suspect the same behaviour might happen on other videos that are played by flash

[15:35:49 CST(-0600)] <cindyli> ie8

[15:36:59 CST(-0600)] <cindyli> however, even html5 video with ie8 uses flash to play but it fires the same events as html5 browsers

[15:38:41 CST(-0600)] <cindyli> youtube is the only confirmed case for now

[15:42:40 CST(-0600)] <Bosmon> Ok

[15:43:06 CST(-0600)] <Bosmon> Well, it seems that this logic could be put into a little dedicated component which relays changes of model.totalTime !== 0 into changes of visibility of the scrubber

[15:43:20 CST(-0600)] <Bosmon> That would at least tidy the logic, and you could leave the issue of when to enable this component as a separate problem

[15:46:11 CST(-0600)] <colinclark> arashs: This is quite technical, but I thought the W3C's "Indie UI" working group might have some thinking that interests you in quest to understand keyboard shortcuts and how they can be adapted...

[15:46:15 CST(-0600)] <colinclark> http://www.w3.org/TR/2013/WD-indie-ui-events-20130122/

[15:46:32 CST(-0600)] <colinclark> "IndieUI: Events 1.0 is an abstraction between physical, device-specific user interaction events and inferred user intent such as scrolling or changing values. This provides an intermediate layer between device- and modality-specific user interaction events, and the basic user interface functionality used by web applications. "

[15:48:11 CST(-0600)] <arashs> this is great

[15:48:20 CST(-0600)] <arashs> thanks colinclark

[15:50:12 CST(-0600)] <cindyli> Bosmon: but that little dedicated component won't help with hiding the scrubber when totleTime === 0 as long as scrubber is initially shown

[15:51:01 CST(-0600)] <cindyli> shall we hide the scrubber initially and show it in the listener handler for model "totalTime"?

[15:53:34 CST(-0600)] <Bosmon> cindyli - if possible, the scrubber visibility state should be exactly synchronised with the condition totalTime != 0

[15:53:53 CST(-0600)] <Bosmon> I imagine the initial default value for the model totalTime is 0, in which case the initial default value for visibility should be hidden

[15:54:41 CST(-0600)] <cindyli> ah, i think I know what you mean. will give it a try. thanks, Bosmon

[15:55:20 CST(-0600)] <Bosmon> Good luck, cindyli

Browser not supported