19:04:29 <RRSAgent> RRSAgent has joined #w3conf-scribe
19:04:29 <RRSAgent> logging to http://www.w3.org/2011/11/15-w3conf-scribe-irc
19:05:00 <chaals> rrsagent, make log public
19:09:11 <chaals> scribe: chaals
19:09:28 <chaals> Topic: Divya (starting in "media res")
19:09:50 <chaals> Divya: Multiple columns - a ways to control columns in pages and let test flow through them
19:10:27 <chaals> ... break-* properties and column-span to let you put headings and stuff into the flow across the columns (like ehadlines in a newspaper)
19:10:50 <chaals> ... default fill is balance - keep them all the same length.
19:11:02 <chaals> ... or you can fill a given height first
19:11:12 <chaals> ... Browser support is good, backward compatibility story works too.
19:11:21 <chaals> ... have a new spec called Regions.
19:11:35 <chaals> ... lets you connect different content boxes
19:11:50 <chaals> [/me thinks of SVG text areas and flow from a decade ago]
19:12:15 <chaals> Divya: You name a flow, and then associate it to elements.
19:13:32 <chaals> ... positioning then works relative to the regions defined, not the viewport as a whole
19:13:52 <chaals> ... there are limited properties you can set directly for the content flowing through regions.
19:14:20 <chaals> ... There is getNamedFlow API, and getRegionsByContentNode
19:14:41 <chaals> ... overflow tells you if the region is full, contentNode says which nodes are in a flow.
19:16:36 <chaals> Divya: Also have exclusions, to take things outside the normal flow, e.g. in the way that magazines layout pictures
19:17:00 <chaals> ... wrap-flow lets you define where things will flow into and where they won't.
19:17:58 <chaals> [shows the idea in action]
19:18:13 <chaals> ... wrap-margin as well
19:18:34 <chaals> ... and wrap-padding.
19:19:56 <chaals> ... Shape-outside lets you use SVG-style shapes to wrap things more interesting than rectangular boxes.
19:20:04 <chaals> ... can also use SVG itself, or an image.
19:20:22 <chaals> [shows wrapping a star and a circle inside it]
19:20:42 <chaals> Divya: Grid is another proposal. Everyone loves grids, there have been several proposals and frameworks.
19:21:05 <chaals> ... http://dec.w3.org/csswg/css3-grid-align
19:21:35 <chaals> ... shows a demo of what and how.
19:24:12 <chaals> ... IE10 has support of a current version, but the spec is likely to change.
19:24:25 <chaals> Divya: Finally flexbox. Who uses it?
19:24:36 <chaals> ... too bad, it ahs changed so you need to change your work.
19:24:55 <chaals> ... helps deal with more powerful use of box layout.
19:25:14 <ajf> ajf has joined #w3conf-scribe
19:25:52 <chaals> ... instead of a lot of script or complex structures of elements and CSS this simplifies things
19:26:07 <chaals> rrsagent, pointer?
19:26:07 <RRSAgent> See http://www.w3.org/2011/11/15-w3conf-scribe-irc#T19-26-07
19:26:15 <chaals> rrsagent, pointer
19:26:15 <RRSAgent> See http://www.w3.org/2011/11/15-w3conf-scribe-irc#T19-26-15
19:26:27 <ajf> oh, I see
19:27:10 <chaals> ... [talks about triggers for different flows, too fast for scribe to catch]
19:27:25 <chaals> ... A box can be a region, grid or flexbox, but not all at once.
19:27:36 <chaals> ... A flexbox can't be something else...
19:27:42 <chaals> [shows a table that clarifies this]
19:27:50 <tantek> tantek has joined #w3conf-scribe
19:27:54 <stearns> stearns has joined #w3conf-scribe
19:28:01 <chaals> Divya: Be aware that the specs are changing - syntax is in flux, as well as semantics.
19:28:08 <martndemus> martndemus has joined #w3conf-scribe
19:28:15 <rbuckton> rbuckton has joined #w3conf-scribe
19:28:19 <stearns> stearns has left #w3conf-scribe
19:28:19 <chaals> ... So be *VERY* careful using it in production - experiment, not putting it on stable sites.
19:28:44 <chaals> ... use feature detection, and make sure that things work whether or not the particuar shiny toy works.
19:29:06 <chaals> [recommends Nicole Sullivan's article on mediablocks ()@stubbornella)]
19:29:21 <chaals> Divya: There is also a jQuery plugin called isotope
19:29:27 <chaals> ... shows what it does.
19:29:44 <chaals> ... can't do that with CSS *today* easily
19:30:02 <chaals> rrsagent, draft minutes
19:30:02 <RRSAgent> I have made the request to generate http://www.w3.org/2011/11/15-w3conf-scribe-minutes.html chaals
19:30:08 <hober> hober has joined #w3conf-scribe
19:30:33 <ajf> ooh
19:30:36 <ajf> commeentary
19:30:40 <chaals> Divya: We always want feedback. There is a mailing list - www-style@w3.org
19:30:41 <ajf> *commentary
19:30:48 <chaals> s/ooh//
19:31:09 <chaals> ... most of what is there comes from people who have too much spare time - be prepared to filter the "fire hose" of content.
19:31:30 <chaals> ... but if you have an issue to raise - unclear wording in a draft, a use case not covered, whatever, that's where to send them so people can figure out what to do.
19:31:44 <chaals> ... Experiment. Submit Bug Reports to tools
19:31:51 <chaals> s/commeentary//
19:31:56 <chaals> s/*commentary//
19:32:12 <chaals> Divya: That's it. Questions?
19:32:30 <ajf> Yes, I have a question, are you reading this?
19:32:57 <becka11y> becka11y has joined #w3conf-scribe
19:32:57 <ajf> Apparently not.
19:33:17 <chaals> Topic: Vincent Hardy - graphics.
19:33:32 <ajf> RRSAgent: pointer?
19:33:32 <RRSAgent> See http://www.w3.org/2011/11/15-w3conf-scribe-irc#T19-33-32
19:33:42 <chaals> Vincent: I'm passionate about the web and graphics.
19:34:04 <chaals> ... I spent a lot of time on 2d imperative graphics, then stated to work on SVG 10 years ago.
19:34:18 <chaals> ... and got a passion for graphics (I learned to do other computation stuff)
19:34:24 <Alan> Alan has joined #w3conf-scribe
19:34:26 <chaals> ... Then went to ork on data visualisation.
19:34:37 <Alan> Alan has left #w3conf-scribe
19:34:44 <chaals> ... Working with what was available on teh web 5 years ago
19:34:49 <ajf> s/ork/work
19:35:33 <chaals> Vincent: Have some thumbnails of intersting demos. Slides will be available so you can peek into the demos including things I can't show during the presentation.
19:36:01 <ajf> s/intersting/interesting
19:36:02 <chaals> ... [Shows a graphical clock made with Raphael - JS framework from Dmitry Baranovsky]
19:36:13 <ajf> s/Have/Here I have
19:36:20 <chaals> ... [shows some moving blotches that are cool]
19:36:38 <chaals> ... There are a lot of cool things you can do. So... How?
19:37:03 <chaals> ... You have 3D capability from WebGL, CSS shaders coming, 2d with SVG and canvas, lots of stuff for animation in CSS and the SVG animation markup.
19:37:20 <chaals> ... You can choose to work with imperative or declarative models.
19:37:40 <chaals> ... You can do layout (that's what CSS is for), visual effects, and there is a wide spectrum of JS frameworks.
19:37:47 <chaals> ... I won't over everything now :)
19:37:53 <ajf> s/over/cover
19:38:08 <chaals> ... Most immediate thing is 2D graphics. SVG and canvas are in all browsers today so I will focus on that.
19:38:15 <chaals> ... There are two models:
19:38:26 <chaals> ... imperative, which is canvas, and declarative which is SVG
19:38:42 <chaals> ... (cf Web3D, WebGL for 3D)
19:38:59 <chaals> ... In an imperative model you have a rectangle, and you draw pixels on it so you have a big array of pixels.
19:39:21 <chaals> ... In SVG you have something that looks like HTML. You have nodes that you put in a DOM and they behave like HTML nodes do.
19:39:37 <chaals> ... There are reasons for choosing one or another in a different case.
19:39:45 <chaals> [who has used each one? A few...]
19:40:02 <chaals> Vincent: [shows picture] How many circles?
19:40:17 <ajf> s/circles?/circles are there?
19:40:22 <chaals> ... [looks like 4, it is 2 in the code, using a different colour to stroke the outline]
19:40:46 <chaals> ... [shows SVG source - elements for circle, attributes controlling visual rendering]
19:40:55 <chaals> ... This is declarative - you are not writing a program.
19:41:21 <chaals> ... Cavas is different. You make a canvas element, and then write scripts to describe how to put pixels into the canvas.
19:41:28 <chaals> s/Cavas/Canvas/
19:41:29 <ajf> s/Cavas/Canvas
19:41:46 <chaals> [shows more source code, for canvas example]
19:42:12 <shepazu> shepazu has joined #w3conf-scribe
19:42:33 <chaals> ... [describes what is happening in the code]
19:42:51 <chaals> ... This is called "immediate mode because you just give instructions, they are done, and what you have left is just a set of pixels.
19:43:07 <ajf> /s/"immediate mode/"immediate mode"
19:43:30 <chaals> Vincent: What is rendered? Shapes, text, images are the three basic kinds of object.
19:43:48 <chaals> ... in SVG you render elements, in canvas drawing calls in script
19:44:02 <chaals> s/drawing/you make
19:44:10 <chaals> s/calls/calls to drawing methods
19:44:25 <chaals> ... There is a rendering context. In canvas it is the context object, in SVG it is implicit.
19:44:40 <chaals> ... all the things you define resolve into the computed rendering.
19:44:49 <chaals> ... [notes that CSS works in SVG too]
19:45:12 <chaals> ... Rendering context has lots of things in it - transforms, styles, text properties, ...
19:46:03 <chaals> ... You can define things like opacity, compositing a specific piece, ...
19:46:22 <chaals> ... filter effects are a very cool feature, to blur, create shadows, etc.
19:46:28 <chaals> ... and masking, clipping, ...
19:46:51 <chaals> ... Rendering context is not the same in SVG and canvas, but at a high level they do the same basic things
19:47:39 <chaals> ... Events in canvas means you have to work out what the pixels that got clicked on actually meant in the image.
19:47:53 <chaals> ... in SVG you're clicking on an object, so it is like HTML - you know what thing got clicked.
19:48:18 <chaals> ... SVG has pointer-events that let you decide what kind of events will work where.
19:49:13 <hiroki> hiroki has joined #w3conf-scribe
19:49:16 <chaals> ... e.g. pointer-events: visible-painted means anything visible catches the event - visible-fill catches on visible things that are fill, but not the stroke ...
19:49:26 <matt> matt has joined #w3conf-scribe
19:49:52 <chaals> [more source code...]
19:50:05 <chaals> Vincent: Some hooks for scripting in canvas and SVG
19:50:36 <chaals> ... canvas *is* scripting. SVG has a DOM, so you have APIs that let you poke things around with script - text properties, manipulating path data, ...
19:51:23 <chaals> [demo of randomly putting dots on a defined path. Which is done by getting the path and then scripting things onto it]
19:52:02 <chaals> Vincent: Animation can be done with scripting (as per last demo). A lot of people resort to that because animation support is not yet universal.
19:52:08 <chaals> ... and in canvas that is how you do it.
19:52:39 <chaals> ... In SVG you can use SVG declarative animation (except in IE at the moment), CSS animation coming.
19:52:45 <chaals> [shows demo]
19:52:57 <Tom> Tom has joined #w3conf-scribe
19:53:18 <chaals> Vincent: [explains the code]
19:53:37 <chaals> ... It can also be further manipulated with the DOM
19:54:00 <chaals> ... Big fan of CSS animation, but doesn't have timing and synchronisation
19:54:13 <chaals> ... I have to hook in scripts to do it, and a slight delay can make a mess.
19:54:37 <chaals> ... Advantage of declarative animation is that I can have one animation start when another is finished, etc.
19:55:02 <chaals> [more demos - building a newton's cradle with a few lines of SVG animation]
19:55:20 <chaals> Vincent: Hope we get those features into CSS animation some time.
19:55:40 <chaals> ... SVG uses CSS styling so you can do things you do in HTML documents
19:56:10 <chaals> ... So I can easily provide high-contrast, etc.
19:56:27 <ajf> s/high-contrast/high-contrast mode
19:56:35 <chaals> Vincent: Multimedia integration is interesting.
19:56:52 <chaals> ... there is audio tag in HTML5 (and in SVG)
19:57:00 <chaals> ... so you can get events and manipulate it.
19:57:51 <chaals> ... Web audio API (in development, currently multiple proposals) is really interesting. Lets you do interesting connection between graphics and audio
19:58:32 <chaals> [Demo of using graphic effects alongside audio, based on timing the sound and making graphics to match]
19:58:58 <chaals> -> http://svgwow.org  some of these demos
19:59:47 <chaals> [Next demo triggers directly from the audio to generate objects accoding to particular frequencies being hit]
20:00:20 <chaals> Vincent: Canvas can render video into a canvas and then let you mess with it...
20:01:06 <chaals> ... filtering, seeking into some part of the video, ...
20:01:20 <chaals> ... pretty straightforward DOM programming.
20:02:24 <chaals> [demos applying a filter effect live to a video]
20:03:19 <chaals> Vincent: Why do we have two different models? Do we need them?
20:04:00 <chaals> ... Canvas is low-level, useful, but missing lots of nice features. SVG has all that but no pixel-level access...
20:04:41 <chaals> ... The debate is false. You *could* do everything with one or the other, but you probably should choose depending on your actual use case
20:05:23 <chaals> [Demo: graffiti effects and the use cases for mix'n'match]
20:06:13 <chaals> Vincent: To spray lots of dots canvas is great - simple, quick, while SVG is good for saving a path...
20:06:38 <chaals> ... Sometimes the two can be combined.
20:06:54 <chaals> ... How to do that is interesting - how do we mix HTML5, canvas and SVG?
20:07:06 <chaals> ... HTML5 into SVG via foreignObject
20:08:05 <chaals> ... To integrate SVG and canvas, can have a canvas in a foreignObject within an SVG
20:08:39 <chaals> [demo SVG/canvas layer upon layer upon...]
20:09:16 <chaals> Vincent: Or use toDataURL
20:10:04 <hiroki> hiroki has left #w3conf-scribe
20:10:29 <chaals> [Demo of rendering a pattern into a canvas, using that to create an image to use as a pattern - much lighter than doing it in pure SVG]
20:11:21 <chaals> Vincent: planned toBlob will be better - manipulating base64-encoded images is clunky. Hoping this will be widely supported soon.
20:11:43 <chaals> ... Or use SVG in canvas, since it lets you draw images into it.
20:12:15 <chaals> [demo using SVG to create part of an image, and canvas to repeatedly paint it for a visual effect]
20:12:51 <chaals> Vincent: Takeaway - combinging SVG and canvas lets you do things more efficiently.
20:13:05 <chaals> ... There are also lots of Frameworks you can use... why would you?
20:13:20 <chaals> ... There are some that implement a feature which is not yet widely supported.
20:13:45 <chaals> ... Or provide a feature specifically useful to a given domain. Or help portability...
20:14:31 <chaals> ... Raphael.js is popular, isloates you from platform so it can render to VML in old IE.
20:15:31 <chaals> ... Paper.js sits on canvas. Easle.js comes from a flash developer, check out his game "pirates love daisies" which he developed the framework for.
20:15:42 <chaals> ... Follw the D3.js talk later in this conference
20:16:08 <chaals> ... And there are frameworks to extend support across browsers by faking things not available in some browsers.
20:16:43 <chaals> ... There are lots more, of course. Choose carefully.
20:17:40 <chaals> Vincent: Canvas good in all browsers. SVG very good, missing fonts (ff/ie) and animation (ie) still
20:18:00 <chaals> ... that's unfortunate. Would be nice to get the interoperability to developers.
20:18:19 <chaals> ... WebGL is coming - some support in most browsers.
20:18:34 <chaals> ... Also some issues with foreignObject and inline SVG that are still being worked on.
20:18:43 <chaals> ... Lot of coolness coming, too.
20:19:35 <chaals> ... e.g. typography, and more.
20:21:05 <chaals> [Questions bumped to lunchtime]
20:21:20 <chaals> Ian Jacobs: It is really ahrd to build a large complex platofrm in a standards body.
20:21:42 <chaals> ...SVG, canvas, etc are developed by groups that are originally different communities. How do we bring them together and make them merge nicely?
20:21:56 <chaals> ... That's somewhere you the people can help by participating
20:22:01 <chaals> [LUNCHTIME]
20:22:06 <chaals> rrsagent, draft minutes
20:22:06 <RRSAgent> I have made the request to generate http://www.w3.org/2011/11/15-w3conf-scribe-minutes.html chaals
20:23:06 <ajf> OK er
20:23:11 <ajf> might want to remove some stuff by me
20:23:33 <ajf> yeah, it's ignored my corrections
20:23:54 <ajf> oh
20:24:38 <ajf> some was ignored, some now
20:24:39 <ajf> hm
20:41:43 <scribe> scribe: ajf
20:42:02 <ajf> scribe: ajf
20:42:11 <ajf> Someperson: something
20:42:15 <ajf> ... something else
20:42:20 <ajf> ... hence <blink>
20:42:38 <ajf> RRSAgent, draft minutes
20:42:38 <RRSAgent> I have made the request to generate http://www.w3.org/2011/11/15-w3conf-scribe-minutes.html ajf
20:43:05 <ajf> oh cool, that actually worked
20:43:17 <ajf> er, enough of my messing with this process.
20:43:40 <ajf> scribe: chaals, ajf
20:44:57 <ajf> scribe: chaals
20:45:19 <ajf> scribenick: chaals
21:08:05 <becka11y> becka11y has joined #w3conf-scribe
21:12:44 <chaals> s/oh cool, that actually worked//
21:13:04 <chaals> s/OK er//
21:13:25 <chaals> s/er, enough of my messing with this process.//
21:13:41 <chaals> s/might want to remove some stuff by me//
21:13:55 <chaals> s/yeah, it's ignored my corrections//
21:14:11 <chaals> s/... hence <blink>//
21:14:22 <chaals> s/... something else//
21:14:35 <chaals> s/Someperson: something//
21:14:53 <chaals> s/hm//
21:15:00 <chaals> s/some was ignored, some now//
21:15:06 <chaals> s/oh//
21:19:26 <shepazu> shepazu has joined #w3conf-scribe
21:22:51 <ajf> chaals: gonna draft that again>
21:29:48 <chaals> chaals has joined #w3conf-scribe
21:30:31 <ajf> good, you're back
21:30:35 <ajf> scribe: chaals
21:30:35 <chaals> rrsagent, pointer?
21:30:35 <RRSAgent> See http://www.w3.org/2011/11/15-w3conf-scribe-irc#T21-30-35-1
21:30:48 <chaals> s/chaals: gonna draft that again>//
21:31:42 <chaals> Topic: Housekeeping...
21:31:54 <shepazu> shepazu has joined #w3conf-scribe
21:32:02 <chaals> IanJacobs: Pleae limit number of devices used, IPv4 is running out.
21:32:22 <chaals> ... Video will be linked tonight, and broken into chunks tomorrow. Presentations linked this week.
21:32:30 <tantek> tantek has joined #w3conf-scribe
21:32:41 <chaals> ... We will have a feedback form later, please start thinking about your feedback.
21:32:49 <chaals> Topic: Arvind Jain, Web Performance
21:33:33 <chaals> Arvind: I work at Google, going to talk about new APIs designed to improve performance on the Web.
21:33:49 <chaals> ... W3C performance group created last year to build things that make pages fast.
21:34:03 <chaals> ... To make things faster, you need to know how fast they are now. So we have Web Timing APi.
21:34:18 <ajf> s/Web/the Web/
21:34:32 <chaals> ... show developers what things are using time on what device/browser/...
21:34:34 <tantek> tantek has joined #w3conf-scribe
21:34:50 <chaals> ... needs to be detailed information.
21:35:04 <chaals> ... At multiple levels - network, DOM, ...
21:35:28 <chaals> ... 4 Specs: Navigation timing, resource timing, user timing and performance timeline.
21:35:44 <chaals> ... Will talk about this.
21:35:57 <tantek> tantek has joined #w3conf-scribe
21:36:24 <chaals> Arvind: Navigation timing allows developer to see timing attributes at network, DOM, HTTP level.
21:36:37 <chaals> ... and where the page comes from - cache, live navigation, ???
21:37:00 <chaals> ... because that is important information to understand what is happening to slow things down.
21:37:03 <dsample> dsample has joined #w3conf-scribe
21:37:16 <chaals> [chart of the process that happens to load a page]
21:37:36 <chaals> Arvind: How long does the DNS lookup take? DOM events? when is the page completely loaded, ...?
21:38:23 <chaals> ... So now it is possible to get a complete picture instrumenting the entire process.
21:38:55 <chaals> ... support already in IE, FF, Chrome, Android. Specification is almost through the process (aiming for Proposed Rec this month)
21:39:24 <chaals> ... Navigation timing isn't fine grained enough. Pages have lots of resources, and fetching them is often most of the time spent.
21:39:47 <chaals> ... Resource timing API provides time spent on individual resources (images, scripts, ...)
21:40:22 <chaals> ... How long does it take to connect to the server that hosts a particular resource, etc.
21:41:08 <chaals> ... attributes like fetchStart, connectEnd, secureConnectionStart, etc...
21:41:26 <chaals> ... redirectStart is interesting. Sometimes there are a chain of these to follow through.
21:42:05 <hiroki> hiroki has joined #w3conf-scribe
21:42:30 <chaals> ... User timing provides high precision timer and method to buffer/retrieve information provided.
21:42:48 <chaals> ... add a mark (name, time value).
21:43:01 <chaals> ... and measure time between two marks.
21:43:32 <chaals> ... Performance Timing API is really just a wrapper around the others.
21:43:45 <chaals> ... give a single interface to access them.
21:44:53 <chaals> Arvind: Timeline: expect implementation early next year, and then move the specs to Recommendation.
21:44:53 <ajf> s/give/giving/
21:45:13 <chaals> Arvind: Some security things we ran across developing this.
21:45:35 <chaals> ... with resource timing we allow a resource to send a header back to the browser on a cross-domain request, to get the timing information.
21:45:52 <chaals> ... It is easier to detect if a user is behind a proxy.
21:46:22 <chaals> ... Deducing from the relative times to connect. Real concern that browser cannot mitigate.
21:46:45 <chaals> ... We ended up deciding this isn't a sufficiently big problem to outweight the benefits
21:47:03 <chaals> ... We think we're not adding much value for fingerprinting attacks.
21:47:49 <chaals> ... There are live usage of these APIs on the web.
21:48:07 <chaals> ... allowing developers to find out how fast their apps run.
21:49:07 <chaals> [shows screenshot and describes Google analytics' use]
21:49:34 <sylvaing> sylvaing has joined #w3conf-scribe
21:49:40 <chaals> Arvind: Page Visibility. This allows developer to know when the visibility of a page changes.
21:50:04 <chaals> ... quite a few use cases. Many applications are doing a lot of owrk, but if they knew the app was not visible they could scale back resource use.
21:50:25 <chaals> ... Also allows tracking of how long a user spends on a particular page.
21:50:34 <hiroki> hiroki has left #w3conf-scribe
21:51:08 <chaals> ... (metrics used to be pretty inaccurate for this)
21:51:55 <chaals> ... has document.hidden (boolean) or a visibility state that has more info
21:52:27 <chaals> ... e.g. preview thumbnails, etc.
21:52:38 <chaals> ... and an event for when things change.
21:52:58 <chaals> ... similar timeline.
21:54:38 <chaals> ... Some implementation, more coming.
21:54:54 <chaals> ... Used in Google Analytics to see exactly what users are looking at.
21:55:13 <chaals> ... and for preloading content to give it faster.
21:55:27 <chaals> ... If you guess right what the user is going to look at.
21:56:02 <chaals> ... Questions?
21:56:56 <chaals> Ni: Engineer from Disney. We're looking into HTML5 video streaming live. We are using Apple's HLS, but nothing like that for Android. So, what are browser vendors thinking about this?
21:57:16 <chaals> Arvind: I don't work on it, so can't really comment. Seems like a good standard that could make live streaming work.
21:58:19 <chaals> Paul Cotton, Microsoft / HTML5 co-chair: W3C's HTML5 and Web/TV Interest groups met 2 weeks ago and had good discussions on making streaming work beter
21:58:30 <chaals> ... I will be here today tomorrow and happy to talk about this more.
21:58:46 <chaals> ???, U Washington: Can you use this for usability testing? Is anyone doing this?
21:59:01 <chaals> Arvind: That is what people are doing - what takes time and how does that affect the user experience?
21:59:55 <chaals> ... if something takes too long to load there is a performance problem. We can see other interesting things, e.g. how long does it take for a user to click on something as a pointer to whether the right things are there.
22:00:23 <chaals> ??: Would you encourage using image bundles or keep images as individual resources?
22:01:26 <chaals> Arvind: More resources == slower load. There is a tendency to consolidate objects. Mostly works well, but it depends on the case.
22:01:39 <chaals> ... large cacheable images, probably not so helpful.
22:02:05 <chaals> ... we want to improve this. SPDY an example of trying to minimise the issue for multiple requests.
22:02:13 <chaals> s/for/of/
22:02:27 <chaals> ... hopefully the question becomes irrelevant in the future, with new protocols....
22:06:39 <chaals> Ben, UWash: ?? + what about people faking the metrics
22:06:55 <chaals> Arvind: The benefit is primarily for the publisher, so there isn't that much value in them doing it.
22:07:28 <chaals> Chaals, Opera: If we keep opening very very small increases in attack surfaces, how do we decide that we've added a lot of them and they add up to a real problem?
22:07:54 <chaals> Arvind: Difficult question. We really defer this to security people, but we do need to consider it.
22:08:55 <chaals> Topic: John Allsopp - Appcache and offline apps.
22:08:59 <chaals> John: G'day.
22:09:34 <chaals> ... A common criticism of the web is that it only works online, whereas native apps can work offline.
22:09:56 <chaals> ... But that isn't true. I'll talk about appcache - which also helps performance but I won't talk about that today.
22:10:10 <chaals> ... To use appcache: create a manifest.html, and then upload and serve it.
22:10:39 <chaals> ... Appcache manifest is a textfile specifying three kinds of files - those that are always in cache, those taht are never, and those that can do it either way.
22:11:01 <martndemus> s/taht/that/
22:11:11 <chaals> [slides, which are online, are pretty clear :) ]
22:11:52 <chaals> John. Stuff that is always coming from the cache comes from it even if the files are actually available because the network is there
22:12:09 <chaals> [CMN: That lets you preload and store things to reduce load time eg for large images or something]
22:12:20 <chaals> s/John./John:/
22:12:40 <chaals> John: Network section specifies things that should never be taken from cache.
22:13:23 <chaals> ... and Fallback - things to use if you can't get a resource from the web.
22:14:59 <chaals> ... NETWORK includes meaning "bypass the old browser cache, too"
22:18:47 <chaals> [Tips and tricks, clearly expressed in the slides]
22:20:25 <chaals> John: Version number in the manifest file being changed causes the manifest to be recached - it's like "touch"
22:20:59 <chaals> ... I have a mistake here. IE 10 *does* support appcache now.
22:21:18 <chaals> ... Backward compatibility story is clear. "You're offline - what did you want?"
22:22:34 <chaals> ... Introduces http://www.westciv.com/manifestr
22:22:59 <chaals> ... bookmarklet to make pages use appcache. But think when you use it for best results.
22:23:58 <chaals> ... -> bit.ly/ummSW slides, links, ...
22:24:20 <chaals> s|bit.|http://bit.|
22:24:34 <chaals> rrsagent, draft minutes
22:24:34 <RRSAgent> I have made the request to generate http://www.w3.org/2011/11/15-w3conf-scribe-minutes.html chaals
22:25:23 <chaals> Topic: Rajesh Lal, apps for mobile and TV world.
22:26:05 <chaals> Rajesh: The N-Screens problem - you'll hit it developing apps for multiple connected devices
22:27:21 <chaals> ... talking about mobile smartphone, PC, tablet, TV
22:27:31 <chaals> [/me wonders where the millions of feature phones went]
22:28:03 <chaals> Rajesh: When creating an app for these devices, start from the design problem.
22:29:26 <chaals> [slides describe more - 1' / 3' / 9', differences in input, user focus, etc]
22:29:38 <chaals> Rajesh: You don't want to get interrupted when watching TV.
22:30:05 <chaals> ... You have a choice between native and web app.
22:30:33 <chaals> ... Native is great for THAT device, but expensive.
22:30:48 <chaals> ... not scalable.
22:31:25 <chaals> ... Web app solution is the step in the right direction. HTML5 is the engine. (HTML5 was originally called web applications 1.0)
22:32:09 <chaals> ... Apps can be on the browser, or wrapped in a native container as a hybrid application built in HTML5 but easy to distribute to devices.
22:32:42 <chaals> [a "history" adding various functionalities at various stages]
22:33:32 <chaals> Rajesh: Simultaneous with development there was a mobile revolution.
22:34:07 <chaals> ... Web app - easy to develop, but web platform is work in progress. Challenges in porting to n-screens.
22:35:19 <chaals> ... Challenges. 1: Feature detection.
22:35:38 <chaals> ... stop browser sniffing, just look for the feature you want.
22:38:11 <ajf|offline> goodnight
22:41:28 <chaals> chaals has joined #w3conf-scribe
22:41:46 <chaals> s|http://bit.ly/ummSW|http://westciv.com/speakEasy/presentations/appcache/appcache-presentation.html|
22:41:47 <chaals> ... use Modernizr / jquery
22:41:47 <chaals> ... 2. Layout detection. Ladder of better and better scenarios.
22:41:47 <chaals> ... Media queries [example], or use jquery if it isn't there, or ... down to JS window.width etc
22:43:29 <chaals> ... via viewports, device oreientation/layout, and so on.
22:43:43 <chaals> ... 3. Advanced graphics. CSS3 etc.
22:44:32 <chaals> ... you start with -ms-foo -o-foo -mos-foo etc etc, and end up with a standard property.
22:44:41 <chaals> 4. Animation.
22:44:52 <chaals> s/4./... 4./
22:45:01 <chaals> ... WebGL, SVG, Canvas, ... what when?
22:45:23 <chaals> ... WebGL is awesome if you have it. CSS3 is fantastic. canvas, SVG, javascript.
22:46:46 <chaals> [shows animation in SVG / canvas]
22:47:04 <chaals> s/animation/code examples for/
22:47:34 <chaals> s/code examples for/explanation of how animation works/
22:48:45 <chaals> [CSS3 animation - nice and clean]
22:49:17 <chaals> Rajesh: I think WebGL is the most awesome
22:49:31 <chaals> ... 5. Audio/Video. Challenge is the audio.
22:49:43 <chaals> ... HTML5 tag is limited, can't be used for sound effects
22:50:22 <chaals> ... flash audio, audio data, some webkit specific thing
22:50:48 <chaals> ... 6: Ajax for cross domain calls.
22:51:09 <chaals> ... You need to get things from the cloud.
22:51:33 <chaals> ... CORS, or write a proxy, or JSONP or a hybrid app
22:51:52 <chaals> ... (decresing order of preference)
22:53:01 <chaals> ... hybrid app lets you access cross domain by removing the HTML cross site restriction.
22:53:46 <chaals> ... 7. Advanced APIs for all screens, and what are polyfills and shapes?
22:54:48 <chaals> ... polyfills and shims are for falling back from the real API.
22:55:02 <chaals> ... or all the way down to your javascript code.
22:56:21 <chaals> [demo of using jquery to find out what is available in different browsers
22:56:33 <chaals> s/browsers/browsers]/
22:59:36 <chaals> ... Point is don't worr about what is the browser or device, detect the features and implement functionality and then fall back for unavailable features.
23:01:32 <chaals> [demo of layout adapting via media queries instead of changing the page itself]
23:02:23 <chaals> s|demo of using|-> http://widgets-gadgets.com/html5/ demo of using|
23:02:53 <chaals> Rajesh: Go look at W3C working groups and other resources
23:03:40 <chaals> ... William Gibson: The future is here already, it is just not very evenly distributed
23:04:08 <chaals> rrsagent, draft minutes
23:04:08 <RRSAgent> I have made the request to generate http://www.w3.org/2011/11/15-w3conf-scribe-minutes.html chaals
23:04:36 <chaals> Ian Jacobs: Reception st 5.30 tonight - stick around (plus some intersting stuff between now and then :) )
23:07:39 <koalie> koalie has joined #w3conf-scribe
23:07:47 <koalie> RRSAgent, this meeting spans midnight
23:08:12 <koalie> chaals, done the "don't start new log at midnight utc" trick
23:08:38 <koalie> you've well deserved your "W3C scribe" pin button, I see from the log!
23:08:44 <koalie> chaals++
23:08:58 <koalie> koalie has left #w3conf-scribe
23:17:18 <tantek> tantek has joined #w3conf-scribe
23:18:16 <tantek_> tantek_ has joined #w3conf-scribe
23:39:50 <chaals> rrsagent, pointer?
23:39:50 <RRSAgent> See http://www.w3.org/2011/11/15-w3conf-scribe-irc#T23-39-50
23:41:00 <chaals> Ian Jacobs: Using HTML5 on older browsers...
23:41:29 <chaals> Topic: Ray Bango, polyfills and shims to light up sites in non-modern browsers.
23:41:47 <chaals> Ray: There are some things to atlk about in supporting non-modern browsers.
23:42:02 <chaals> ... I work for MS, am a member of JQuery product team.
23:42:12 <chaals> s/product/project/
23:42:18 <tantek> tantek has joined #w3conf-scribe
23:42:33 <chaals> s/atlk/talk/
23:43:04 <chaals> ... I love the HTML5 t-shirt
23:43:30 <chaals> [slide - a bridge. that has broken...]
23:43:39 <chaals> Ray: Gap is the non-modern browsers
23:44:33 <chaals> ... going to talk about the issues, and the solutions that get us across the gap.
23:44:41 <chaals> ... Biggest problem today is browser support.
23:45:01 <chaals> ... most people have to support non-modern browsers.
23:45:36 <chaals> ... From http://caniuse.com I can see stuff, and decide what *is* modern
23:46:17 <Ian> Ian has joined #w3conf-scribe
23:46:28 <chaals> ... modern browsers have issues for some browser, too.
23:46:42 <chaals> ... fast update browsers have varying levels of support in deployed versions.
23:47:21 <chaals> [market share slide by versions. looks like ants on a white table though]
23:47:46 <chaals> Ray: 0.24% market share is millions of users... not supporting them has a real cost
23:48:26 <chaals> ... it is important to give users a *decent* experience (doesn't have to be *the same*)
23:48:45 <chaals> ... this is a real drag for devlopers.
23:49:04 <chaals> ... Browser detection is a flawed concept today.
23:49:29 <chaals> ... Feature detection is a solution. Cool thing about what browsers are doing is that there is a strong roadmap from W3C with a key set of features.
23:49:39 <chaals> ... checking for thse lets us make our site future-proof.
23:50:07 <chaals> ... addEventListener is a standards so if I check for it and it is there I'm good.
23:50:28 <chaals> ... You might not *use* it. Or you can load script in dynamically.
23:50:50 <chaals> ... You need to manage expectations. There is a responsibility when including someone else's code to mimic API functionality
23:51:34 <chaals> Ray: Bad way to figure it out: use different event listening based on whether something is an MS browser or not.
23:51:57 <chaals> ... assumes MS will keep supporting non-standard stuff for ever, and not support standard stuff.
23:52:18 <chaals> [live coding demo]
23:52:48 <chaals> [big click me link]
23:53:13 <tantek> tantek has joined #w3conf-scribe
23:54:21 <chaals> Ray: Right way s to check for the standard feature. If it is there, use it. And *then* if it isn't there, fall back to some proprietary patch 
23:55:32 <chaals> ... what about when feature detection is pages and pages of code?
23:55:56 <chaals> ... Modernizr is the best option right now
23:56:28 <Ian> [Shout-out to Paul Irish for modernizr]
23:56:29 <chaals> [shows modernizr]
23:58:23 <chaals> chaals has joined #w3conf-scribe
23:59:23 <chaals> Ray: "if (modernizr.canvas && modernizr.audio)" is not really complicated...
23:59:48 <chaals> [demo of a seriously degrading experience if you don't have canvas and audio support]
00:01:03 <chaals> Ray: Polyfills and shims are cool, but entail responsibility.
00:01:10 <tantek> shims/shivs/polyfills
00:01:15 <tantek> polyfix
00:01:34 <chaals> ... Polyfill replicates the standard itself. Shim replicates the functionality, but changes the API. Which means you have to go back and change stuff as the world moves on.
00:02:22 <chaals> ... Nice list of polyfills around. Lots of great code.
00:02:44 <chaals> ... HTML5Shim is a great polyfill
00:03:15 <chaals> ... When you use a 3r party libray, you have to think about supporting it, even if the developer abandons it.
00:03:21 <chaals> s/3r/3rd/
00:03:30 <chaals> ... you have to make sure it really works as advertised.
00:04:00 <chaals> ... You want polyfills that support the same API.
00:04:17 <chaals> ... eg socket.io revamped to match the W3C API, so you on't have to change your code for them.
00:05:07 <chaals> [demo of a blocky layout using div class="..." where ... are HTML5 semantic tags]
00:06:18 <chaals> Ray: Old browsers don't recognise the new tags.
00:07:58 <chaals> ... old IE can't handle new semantic tags. John Resig came up with a workaround. Remy Sharp made it do this for you
00:08:55 <chaals> ... and they put it into Modernizr. Yay.
00:09:44 <chaals> [in demo, adding the shim. But still no internal style sheet for new elements in old browsers]
00:10:01 <chaals> [so adding CSS to extend that too]
00:10:57 <chaals> Ray: You can offer a degraded experience, IE 6 doesn't have to have the same experience as IE9
00:11:31 <chaals> ... but I'm going to use jquery to load something to give rounded corners even in browsers that don't have them.
00:11:37 <chaals> ... this is a shim.
00:11:45 <chaals> [demo now has rounded corners]
00:12:54 <chaals> Ray: Video... and codec support
00:14:15 <chaals> ... you can use <source> in HTML5
00:14:34 <chaals> ... and you can embed an object element for a plugin too.
00:17:13 <chaals> [editor: slightly disturbing expression of possibly inappropriate love of an animated rabbit]
00:17:33 <chaals> [demo of video showing what Ray talked about]
00:18:05 <RRSAgent> I have made the request to generate http://www.w3.org/2011/11/15-w3conf-scribe-minutes.html Ian
00:19:40 <chaals> Ray: Conclusion. HTML5 is good, we depend on it. users depend on us. We depend on their money.
00:19:57 <chaals> ... There are ways to support the world. Use them thoughtfully.
00:20:26 <chaals> ... Polyfills are more future-proof than shims.
00:21:07 <chaals> Q: How do you transform videos into different formats?
00:21:14 <chaals> Rey: There are services that do that.
00:21:31 <chaals> [apparently http://archive.org ]
00:22:32 <chaals> Topic: Christopher Slye, Web Typography
00:24:52 <chaals> [Ironically, the typography of the opening slide looks really bad on the projector. So we have a delay of 2 minutes in a 15 minute talk]
00:25:17 <chaals> Cristopher: Rich typography is coming to the web, some of it is there, more on the way
00:25:35 <chaals> ... there are two basic formats: truetype and postscript
00:25:45 <chaals> ... these are at the root of a lot of compatibility problems.
00:26:03 <chaals> ... good news is that they will hopefully work the same in future web browsers.
00:26:22 <chaals> ... truetype was "the web format" for compatibility with IE 8 and less.
00:26:47 <chaals> ... EOT and WOFF are font containers. EOT for IE only, now we have WOFF.
00:27:21 <chaals> ... a standard compressed font container with metadata capability.
00:28:20 <chaals> ... CSS Fonts 3 gives properties (size, weight, ...), font faces, and features (the exciting bit)
00:28:30 <chaals> ... @font-face really associates a name to a font.
00:29:31 <chaals> ... Web Font Services handle a lot of scary stuff for you. format, subset, license, update, ...
00:30:50 <chaals> ... There are users who set their own browser font properties differently, and are then upset about how your website renders.
00:31:13 <chaals> ... Now we have it, we have to make typography really good
00:31:18 <chaals> ... on the Web.
00:31:40 <chaals> ... For the web, opentype layout is about substitution and positioning.
00:31:59 <chaals> ... glyphs and instructions are not new, but are now exposing themselves to the web.
00:32:11 <chaals> ... beware - subsetting can break things in opentype layout.
00:33:18 <chaals> ... There are default behaviours, for ligatures etc.
00:34:28 <chaals> ... and discretionary features (small caps, arbitrary fractions, ...)
00:34:42 <chaals> ... Example of tying these together and making them look better.
00:37:28 <chaals> Christopher: It's about tying a bunch of stuff together. Specifying and implementing things.
00:37:46 <chaals> ... It's about enabling designers to do real typography and then it is up to them to do it.
00:38:12 <chaals> [no questions]
00:39:35 <chaals> Topic: Paul Irish, HTML5 - the foundation of the Web Platform
00:39:54 <Ian> scribe Ian
00:40:04 <Ian> scribe: Ian
00:40:28 <Ian> paul: what html5 means from a browser perspective, and what's going on under the html5 covers
00:40:45 <Ian> [About Paul....google chrom, modernizr, jquery, html5 boilerplate]
00:40:56 <Ian> ...starts with the doctype
00:41:20 <Ian> [Photo of a cafe centro in San Francisco]
00:41:46 <Ian> [Location of a conversation on doctype between Todd Fahrner and Tantek Celik]
00:42:20 <Ian> ...tantek proposed to use doctype as switch
00:42:32 <Ian> ...for clue to standards support.
00:42:48 <Ian> [Paul reads excerpt from email from todd fahrner]
00:43:11 <Ian> ...todd proposal modal rendering
00:43:51 <Ian> ..tantek prototyped it in IE5 Mac
00:44:01 <Ian> ...at the same time mozilla was discussing with it on bugzilla
00:45:07 <Ian> ...in html5 they looked at how browsers handle the doctype
00:45:27 <Ian> ...idea was that if all browsers treat the same way, the shorter it can be: <!doctype html>
00:45:36 <Ian> ...next step is meta charset
00:46:49 <Ian> ...handled by browsers differently due to how authors were including quotes
00:46:50 <Ian> ...similarly shortened in html5 to <meta charset=utf-8>
00:46:52 <Ian> ...take that as the content type for html5
00:47:03 <Ian> IMPORTANT: Need to define the character encoding for all documents. AND do so before <title>
00:47:18 <Ian> why? because UTF-7 can be used for a scripting attack.
00:47:28 <Ian> s/attack/exploit/
00:48:37 <Ian> ...next topic: parsing -> markup to dom
00:49:14 <Ian> [how parsing happens: tokenization, tree construction, check for document.write......document.write is a jerk!
00:49:58 <Ian> ...in 2002, Ian Hickson started to document how browsers handle invalid markup
00:50:35 <Ian> [Paul shows how browsers historically handled invalid markup to create different, non interoperable dom trees]
00:51:00 <Ian> ... in 2006, hixie wrote live dom viewer to show parsing results.
00:51:32 <Ian> ...real-time view of how a browser parses.
00:51:57 <Ian> ..note that view source is not viewing the constructed dom tree.
00:52:11 <Ian> ...firebug appeared shortly thereafter
00:52:54 <Ian> ...the dom viewer in firebug uses angle brackets in the views (though the brackets are not in the tree itself)
00:53:11 <Ian> ...html5 standardizes parsing of arbitrary markup
00:53:49 <Ian> ...now we have the exact same parser in a variety of browsers
00:54:29 <Ian> ...[quoting Bruce from Opera]: consumers can expect fewer interop problems .... 20% of problems in their study disappeared using standardized parsing
00:54:33 <Ian> ...html5lib
00:54:56 <Ian> ...validator.nu has a live dom viewer
00:55:59 <Ian> ...Google Web Toolkit (GWT) implementation of the parsing algorithm.
00:55:59 <Ian> ...I've been documenting ports in various languages
00:55:59 <Ian> ...java, php, ruby, js, 
00:56:08 <Ian> ...if you are doing screen scraping, I recommend using one of these libraries.
00:56:12 <Ian> [back to the paul sample file]
00:56:27 <Ian> optional start tags: <html><head><body><colgroup><tbody>....
00:57:20 <Ian> ...some end tags optional as well (as they were in html4)
00:57:33 <Ian> Paul: I would close your <p> tags...even if optional.
00:58:01 <Ian> [Paul gets all philosophical about end tags....]
00:58:10 <Ian> Paul: what's important is what your team considers maintainable.
00:58:28 <Ian> ...my main point is that this parsing algo is interoperable...you can feel comfortable writing as shown.
00:58:37 <Ian> ...paul shows a minimal HTML5 document.
00:58:41 <Ian> <!doctype html>
00:58:47 <Ian> <meta charset=utf8>
00:58:55 <Ian> <title>Svelte</title>
00:58:59 <Ian> <p>Cool!
00:59:00 <Ian> ====
00:59:25 <Ian> ...can set language on an <html> element if you want.
00:59:36 <Ian> ...example of google.com/404
01:02:48 <Ian> ...next topic: <script>
01:02:52 <Ian> "innerHTML"
01:02:54 <Ian> [Wayback machine 15 years ago!]
01:02:56 <Ian> ...back to DOM Level 0 API
01:03:00 <Ian> createElement, createTextNode, appendChild,insertBefore
01:03:05 <Ian> ...I was frustrated by having to create a text node to put some text in a div.
01:03:10 <Ian> [Example shown of complex dom level 0 api]
01:05:59 <Ian> ...but innerHTML is much more terse!
01:05:59 <Ian> ...paul shows timeline history of innerHTML
01:06:00 <Ian> 1996...innerHTML on the horizon
01:06:03 <Ian> ..then mozilla does createContextualFragment....
01:06:16 <Ian> [Paul shows the API...create a range, pass a string, return a doc fragment, then ....dissolves into the page like a magical gel!]
01:06:22 <Ian> [more history of dhtml]
01:06:27 <Ian> ...Erik Arvidsson shim : writes an innerHTML polyfill
01:06:29 <Ian> 2000: Mozilla implements innerHTML
01:06:33 <Ian> 2007: Finally specified.
01:06:35 <Ian> ====
01:06:37 <Ian> tags v elements
01:06:39 <Ian> Paul: Don't correct people. You deserve it if you get punched in the face.
01:06:43 <Ian> ...people have tried to define element (set of tags + attributes) v. tag.
01:06:47 <Ian> ...here's what the REAL difference is
01:06:52 <Ian> [paul types some DOM stuff in real time to illustrate]
01:07:42 <Ian> Paul: TAGs exist in string space.
01:07:42 <Ian> Paul: ELEMENTS are objects in memory that are part of the tree
01:07:42 <Ian> ...they have lots of other things like dataset, firstChild, etc.
01:08:17 <Ian> ...so the dom viewers that use angle brackets are PULLING THE WOOL OVER YOUR EYEs
01:08:17 <Ian> ...we've survived being imprecise in these terms
01:08:34 <Ian> [back to demo file]
01:10:10 <Ian> ....html the markup and html the serialization
01:10:21 <Ian> next - Stupid HTML tricks!
01:10:30 <Ian> world's shortest text editor:
01:10:37 <Ian> data:text/html/,<pre contenteditable>
01:10:50 <Ian> turn your browser into an editor in one line!
01:11:06 <Ian> next: what can you used as @id?
01:11:13 <Ian> ....HTML spec says you can use anything
01:11:19 <Ian> ...getElementById() works fine.
01:11:28 <Ian> ...BUT....CSS namespace for IDs is more specific.
01:11:53 <Ian> ...it contains the thing with the ISO character and the something something
01:12:08 <Ian> ...summary: you can use the unicode snowman for an id!
01:12:53 <Ian> ...Matthias's "mothereffing CSS escapes"
01:13:06 <Ian> ...to let you do really twisted ids in css
01:13:16 <Ian> Paul: Quote-free attributes make you feel ALIVE
01:13:28 <Ian> ...like walking around naked in your apartment.
01:13:36 <Ian> ...those quotes were weighing me down!
01:13:52 <Ian> the rule is: no quotes needed unless you have whitespace or some unescaped special chars
01:14:23 <Ian> ...see mothereffing unquoted attribute value validator
01:14:48 <Ian> ...there are rules behind all this and the browsers abide by them
01:15:53 <Ian> next topic: personalized doctypes
01:15:54 <Ian> [some crazy examples including "recursive doctype"]
01:16:16 <Ian> Paul: The HTML5 spec is a repository of valuable brwoser knowledge much acquired through reverse engineering
01:16:25 <Ian> ...check out the authoring view o fHTML5
01:16:33 <RRSAgent> I have made the request to generate http://www.w3.org/2011/11/15-w3conf-scribe-minutes.html Ian
01:18:11 <chaals> scribe: chaals
01:18:18 <chaals> Ian: How do you go from HTML4 to HTML5?
01:18:45 <chaals> Paul: Pretty much just do the doctype switch. Stuff won't break. And then you can upgrade pieces inside it as you reach them.
01:18:58 <chaals> Ian: reception now, breakfast at 7.30am...
01:19:07 <chaals> ... Thanks much
01:19:14 <chaals> rrsagent, draft minutes
01:19:14 <RRSAgent> I have made the request to generate http://www.w3.org/2011/11/15-w3conf-scribe-minutes.html chaals