W3C home > Mailing lists > Public > www-style@w3.org > July 2018

[Houdini] Minutes Sydney F2F 2018-07-02 Part II: Layout API, Typed OM, Custom Paint

From: Dael Jackson <daelcss@gmail.com>
Date: Wed, 18 Jul 2018 18:07:03 -0400
Message-ID: <CADhPm3vuC_48KEmSsvfKKvODYuXSapt15JBZ3_JTtabxspz5AQ@mail.gmail.com>
To: public-houdini@w3.org
Cc: www-style@w3.org
   These are the official Houdini Task Force
     minutes. Unless you're correcting the
      minutes, please respond by starting
 a new thread with an appropriate subject line.

Layout API

  - RESOLVED: Abspos parented to custom layout elements have static
              pos computed similar to flex and grid children (static
              pos rect coincides with parent rect) (Issue #775)
  - RESOLVED: The rules for abspos containing blocks is not changed
              with the presence of custom layout. (Issue #775)
  - RESOLVED: Custom layout must return all fragments, otherwise
              return an error and fall back to block layout. (Issue
  - RESOLVED: Use Promises and add a note about error handling (Issue
  - RESOLVED: No change on Issue #437 (percentageInlineSize /
  - RESOLVED: Intrinsic size in orthogonal flows are taken according
              to the writing mode of the containing block, and
              intrinsic size calculations have to be consistent with
              all other places in CSS (per CSS Sizing). (Issue #776)

Typed OM

  - RESOLVED: Add frremy as co-editor on css-typed-om, move nainar to
              former editor

Custom Paint

  - RESOLVED: Deferred to L2 (Issue #763: optional arguments in paint
  - RESOLVED: Custom Paint to CR


Agenda: https://github.com/w3c/css-houdini-drafts/wiki/Sydney-F2F-July-2018#proposed-topics

Scribe: heycam


Layout API

Missing fragments and absolute children
  github: https://github.com/w3c/css-houdini-drafts/issues/775

  <div style="display: layout(foo);">
    <div id=child1></div>
    <div id=child2>
      <div id=abspos></div>

  iank: In the Layout API, it's possible to have multiple children
  iank: In the example in the issue, the second child has an abspos
        child in it
  iank: Its containing block is higher up in the tree
  iank: Inside of layout, we only lay out the first child, and return
  iank: What should the behaviour of the abspos be?
  Rossen: Is there an expectation for anything to happen to the child
  iank: In the current API, you can just leave out children
  iank: and they don't lay out
  eae: Effectively it's display:none
  eae: so wouldn't it make sense for their children not to show up?

  Rossen: There are two things
  Rossen: either the abspos child will be lifted outside the scope of
          the display:layout function grandparent, or not
  Rossen: If it's lifted outside of it, I'm assuming layout will
          happen in the normal way
  iank: Your assumption is that it will display the abspos child
        somewhere else
  Rossen: If it's position is outside the scope of the display:layout
  Rossen: Would all abspos elements reach their containing block,
          during custom layout?
  Rossen: You can have a bunch of inner levels of custom and normal
  Rossen: Will there be a discontinuity in that process?
  Rossen: My assertion is that it shouldn't
  Rossen: One potential problem is that if you rely on something as
          part of the custom layout, in that interleaving, and that's
          not calculated, you might get wonky results
  Rossen: e.g. if you don't lay out child 2, and the abspos position
          depends on child 2's position, you'll have to synthesize
          something for the static pos
  Rossen: but that's about it, or you might have something that is
          switching writing modes or whatnot
  Rossen: but again my assertion here is that this shouldn't have an
          effect apart from residual things like static pos
  iank: I'm fine with that

  iank: What should happen with the static pos?
  Rossen: (a) we don't want to have a loss of content, regardless of
          what happens to the custom layout parent
  Rossen: i.e. the abspos box should not just disappear, unless you
          explicitly say so
  dbaron: So you're saying it should have its normal abspos
          containing block, and the custom layout is never an abspos
          containing block.
  Rossen: No
  Rossen: My assertion is the box with abspos element will always
          generate a box, and it will be parented to the appropriate
          containing block, which may or may not be custom layout
  Rossen: Distinction is propagating through custom layout layers,
          second is ending up at a non-custom layout containing block
  Rossen: So besides calculating some invalid or default static pos
  iank: Something along the lines of pretend that it did generate a
        (0, 0, 0, 0) fragment

  fantasai: For custom layout, unless we want to let it control the
            static pos, we could certainly just use the rules in
  fantasai: which is you pretend that the static pos rectangle is the
            whole flex container (the abspos’s parent)
  Rossen: What happens if a flex item is the whole area
  fantasai: If display:layout and child2 are both doing custom layout
  Rossen: The outer one is the containing block
  fantasai: The parent gets used as the static pos rect

  ...: if you didn't lay it out
  Rossen: Then its parent
  fantasai: But that box still needs a position
  fantasai: Why isn't there a box?

  dino: On child2 if you put display:none, what happens to abspos?
  Rossen: Same as always, it wouldn't display
  dino: Why is different from not laying it out?
  Rossen: We shouldn't introduce things that are like display:none
          just because didn't lay out a box
  fantasai: It should just be (0, 0, 0, 0)
  dino: Sure
  fantasai: The box should still exist, and you just happen to not
            position it
  Rossen: Just becomes a position and an empty rect
  dino: If it had a position, you'd use that
  Rossen: Which is what I would expect
  iank: Yes
  Rossen: If my containing block is some span e.g., didn't have
          anything else than the abspos, it still has a position
          calculated for it
  eae: Makes a lot of sense

  Rossen: The static position of an abspos element, with a custom
          layout parent, is based on that parent's fragment's box
  fantasai: Similar to how static pos of a box that is parented to a
            flex container uses the rectangle of the flex container to
            calculate it static pos, rather than any hypothetical
            "would have been" layout like block layout
  Rossen: The summary here is that the static pos of abspos elements
          parented to custom layout is the same as in CSS, based on
          the rectangle of that parent
  fantasai: Similar to flex/grid, not block
  fantasai: In block and layout they use the hypothetical position if
            they weren't positioned
  fantasai: For flex and grid, we don't try to calculate where it
            would have been, instead pretend you would have coincided
            with your entire parent

  RESOLVED: Abspos parented to custom layout elements have static pos
            computed similar to flex and grid children (static pos
            rect coincides with parent rect)

  Rossen: Next problem, you've computed static pos, that's great. You
          end up with a custom element that has position:relative
  dbaron: There's an easier piece we should resolve first
  fantasai: Proposal is that custom layout does not interrupt
            propagation of abspos
  dbaron: It doesn't change the rules for when something is an abspos
          containing block
  Rossen: The abspos is never exposed to the custom layout in any form
  iank: Other potential thing is about the behavior of the second
        child, in this case
  iank: You are thinking that child2 should get laid out with
        available size zero, and would still show up?
  iank: It's specced as not showing up
  iank: That might be something easier to resolve on

  RESOLVED: The rules for abspos containing blocks is not changed with
            the presence of custom layout.

  Rossen: Next is, if the containing block is custom layout
  fantasai: If you don't explicitly lay out a child the layout engine
            resolves its size and position to zero
  frremy: I'm fine with that, but it will not show up
  frremy: I think that's ok, but if I don't put return it, I don't
          want it in the layout
  frremy: Similar to display:contents or something
  frremy: If I don't want to include a particular element,
          implementing something like -webkit-line-clamp, I don't want
          them generating

  dbaron: If I were to try to think about how I wanted custom layout
          to deal with being an abspos containing block, I feel like I
          would want to two different options probably
  dbaron: Don't necessarily need both options in v1
  dbaron: One of them would be: I want a custom layout, might be an
          abspos containing block, I want it to handle things I'm the
          abspos containing block for using the default rules
  dbaron: I don't want to handle those in my custom layout, just handle
          the in-flow contents
  dbaron: Other option: I also want to take over layout for the
          descendants I'm the abspos containing block for
  dbaron: and in that case, in many cases I'd want to get those sets
          of children separately
  dbaron: i.e. process the in flow ones first, then the abspos ones

  iank: I could imagine an API that is two additional callback
        functions, one where you're routing children, yes pass this to
        parent, no keep this one to myself
  iank: and an out of flow layout pass, which gives you the children
        you're a containing block for
  iank: and go ahead and apply whatever abspos rules you want
  frremy: That's useful for the grid polyfill
  frremy: If you set grid-column on them you still need to be able to
          place them in columns, even if they're abspos
  frremy: Doesn't have to be in the layout step, could be a separate
  Rossen: Only problem I have with this, is if you select which
          children you want to handle, that goes against the
          resolution we just had before
  frremy: What does grid do?
  Rossen: The API proposed, here are the children going through, I
          want to keep certain ones ... unless we specify we're not
          even going to expose abspos to your children
  Rossen: because you really don't need to
  iank: I think it's a niche use case, a callback for routing
  Rossen: But that's a more advanced feature

  Rossen: So, current issue is, element with custom layout, it's also
          a containing block for abspos, there's a descendant abspos,
          and the custom layout does no layout. what happens to the
          rest of the children?
  Rossen: One of the assertions we should have here is that that
          child, at that level, is just a normal first level child, it
          has to be laid out
  Rossen: It shouldn't be any different from other ones
  Rossen: So if I have two children that are inside of this custom
          layout, one is an immediate child, one is a descendant,
          regardless how deep the descendant is, it's something I need
          to handle at the first level
  Rossen: If I can decline layout for a first level child, I should be
          able to do that for the abspos descendant too
  Rossen: Might be different for layout logic, that's your business
  Rossen: But the point is that I have a collection of children
          fragments that came up to me, if I decide to drop them all,
          I can
  Rossen: From that point of view I don't think we need anything
          specific to abspos, but we still need to be clear as to what
          the rules are
  iank: Yes, we can discuss that

  fantasai: The original issue, we've got an element whose static pos
            we need to find, static pos is not the custom layout in
            this particular case, because it's a child of a child of
            the custom layout
  fantasai: Custom layout is responsible for laying out the child,
            when it does, that box will determine the static pos of
            the grandchild
  fantasai: If the custom layout doesn't lay out that child, we still
            need to know where the static position is
  Rossen: We resolved that
  fantasai: We resolved that for a child of the custom layout, this is
            for a grandchild of the custom layout
  fantasai: It's different because if we don't run layout on the child
            of the custom layout, we don't know where it is
  fantasai: It's a regular in-flow child of the custom layout, inside
            that is the abspos
  fantasai: The abspos's position is dependent on the size/pos of
  fantasai: We don't have answer for the size/pos of child2
  Rossen: My point in the beginning is that the static pos of the
          abspos, is the origin
  Rossen: This is relative to its parent
  Rossen: If the parent doesn't compute to anything, it will be to the
          origin of its parent
  Rossen: At some point there is some ancestor where that origin is
  fantasai: We didn't resolve on that
  Rossen: This is how custom layout is defined to work, relative to
  fantasai: I know it's relative to parent

  dbaron: I think we need a definition of what happens if custom
          layout decides not to lay out something
  dbaron: In our engine, layout code can't not lay out something
  dbaron: I suspect other engines are probably similar
  dbaron: If you get laid out at (0, 0, 0, 0), whatever it is, it
          should be defined somewhere
  dbaron: Once we have that definition, it resolves this.

[-- break 20 mins --]

  Scribe: fantasai (with heycam for fantasai)

  fantasai: Key question is what dbaron said, what do we do to
            fragments which are not laid out?

  frremy: A common use case for not laying out a child is when you
          want, e.g. lay out items until you run out of space and then
          have a continuation marker (like ...)
  frremy: you want to just stop laying out at that point
  frremy: Should try to address this in custom layout
  frremy: makes sense to not generate a box for items that aren't laid
  frremy: rather than defaulting to (0,0,0,0)
  frremy: So prefer to define same as 'display: none' or define
          something else similar
  frremy: or throw an exception for now and figure it out later
  frremy: Don't think it's useful to create a box that's zero-sized,
          this isn't useful
  frremy: and not generating the box is sometimes useful
  Rossen: I think not showing things is useful
  myles: max-lines is similar
  Rossen: Should be able to not lay out. If we don't lay out anything,
          the question is would we absolute generate no fragment/box.
          Would we end up with an empty size and origin position?

  Rossen: We still have to answer questions like from the OM, what's
          the size/position
  Rossen: So what would make the most sense?
  frremy: Compromise would be to have a box at zero/zero, but it just
          doesn't paint
  iank: Agree that we should say it doesn't paint.
  iank: but what about the rest of the subtree?
  iank: Do we return zero for everything all the way down the subtree,
        or do we continue with layout?

  fantasai: For max-lines specifically, from an implementation
            perspective, I think it does make sense to lay everything
  fantasai: That's a use case where you want to hide and show things
            dynamically, not having to re-layout would be useful
  fantasai: More generally I'm not sure
  fantasai: If you're not going to display the stuff
  fantasai: but you could display:none things you don't want to display
  Rossen: But this is a layout time decision
  eae: For max-lines it would be nice to not reflow things that aren't
       going to be displayed, unnecessary work
  koji: This could create next fragments, it's more about
        fragmentation, when the next fragment container is missing
  fantasai: You could make the same argument here
  fantasai: We will support fragmentation

  iank: It might be reasonable to say layout doesn't happen, and all
        CSSOM APIs return zero, getClientRects doesn't anything
  iank: Saying all this without impl experience, might change opinion
        based on experience
  iank: Everything returns zero, empty array for line boxes
  dbaron: I think this is a magical semi-displayed case
  dbaron: I'd rather have a layout and have the APIs return a
          consistent state
  iank: We could also define a consistent state
  dbaron: Sounds messy
  iank: I'm a little bit torn, agree with fremy that use cases for
        this are very valuable

  Rossen: Another lens to use for reasoning, how would you serialize
         your collection of children in the case that frremy gave?
  Rossen: e.g. for accessibility purposes
  Rossen: Would want accessibility tool to walk the same tree as
          what's visible
  Rossen: Would you synthesize things in the AT or what?
  iank: Not accessible to normal users, so shouldn't be accessible to
  iank: The way to make this decision would be, what should happen in
        the max-lines case?
  iank: Could also punt this for now, get impl experience

  iank: Our current behavior is that you need to return all the
        fragments. Otherwise we'll fall back to block layout
  Rossen: That's nice. Very predictable and verifiable
  iank: We should investigate, then reopen this issue.
  Rossen: In which case, this is an error
  iank: Yep
  Rossen: Fix your code. Make it work.
  heycam: I think it might be easy to accidentally lose your custom
  Rossen: Exactly
  heycam: Might be that you change your ordering in certain window
          sizes, and then it breaks
  fantasai: I think if you can't loop correctly over all the items in
            this list ...
  Rossen: You shouldn't be doing custom layout.
  iank: Grid iterates in a particular order
  frremy: But here you need to iterate in the right order

  Rossen: Sounds like for this level of where we are, this is a
          reasonable error case handling
  Rossen: It is simple, it's easy to describe, and should be easy to
          fix on the script side
  Rossen: With that, plus previous two resolutions, then we have a
          clear answer to what happens with abspos children
  Rossen: If we need to get more sophisticated later, we can
  Rossen: Implementation experience may suggest a better pattern
  frremy: Would need to feature detect somehow, whether the browser
          supports laying out all the boxes or not

  iank: Need to resolve on this, then: if you don't return all the
        fragments, we return an error and fall back to block layout
  iank: Falling back to block layout is what happens if the layout
        function throws an error
  iank: You can check by ...
  heycam: What about existing content, that falls back to block
          currently and throws an error, and then later it starts to
          drop content
  fantasai: Could fall back to content disappears?
  fantasai: But we don't like dropping content
  Rossen: We could fall back to 100em bright red...
  iank: Two ways to deal with that.
  iank: One is to use-count
  iank: Other, if that number is sufficiently high, we can add a
        layout option
  iank: It's a bit heavy handed
  iank: but we can use-count it to check
  philipwalton: Could put a note in the spec explaining what we're
                planning to do
  Rossen: This is simple, easy to spec, easy to explain, easy to see
          if you messed up. Can revisit later. It's a good solution.

  RESOLVED: Custom layout must return all fragments, otherwise return
            an error and fall back to block layout.

Generator vs. Promise design for the API
  github: https://github.com/w3c/css-houdini-drafts/issues/750

  iank: Did some benchmarking
  iank: The Promise solution is slightly slower, but not that much
  iank: That makes me lean towards Promises solution
  iank: Advantage of generator is that it's faster, don't have to kick
        the ? every time
  iank: there's some overhead for doing that
  iank: However, I think that's acceptable from an author expectation
  iank: If it was 30-40% overhead, that might be a concern
  iank: but turned out to be not as much of a problem

  Rossen: What did you test?
  iank: Test was 100 custom layout elements
  iank: Went about 6 layers deep, and had two child nodes at each
        level and 4 leaf nodes
  iank: tree structure, roughly 100 nodes
  iank: used our perf testing framework
  iank: I did a synchronous version of the API, didn't have any
        generators, promises, etc. Just executed synchronously
  iank: That was about 650 runs per second
  iank: Our current impl was about 430 runs per second
  iank: so 50% off the synchronous one
  iank: Promises was 450 runs per second
  iank: Might be able to get it faster, push around 500 or something

  iank: We do lose a lot of performance by allowing async here
  iank: so something else to consider
  iank: One thing we could revisit later is, asynchronous layout
  iank: we could potentially get performance by exposing synchronous
        versions of layout APIs
  iank: so leave that door open
  iank: I'll need to do some work, spec wise, to get it so that an
        impl can run this synchronously
  iank: Still requires a queue to go through layout requests
  iank: Once I've got that written down, make sure it makes sense to

  frremy: What if you await Promise that never returns?
  iank: When you call layoutNextFragment(), pushes a request onto an
        internal queue. If layout engine has exhausted that queue
  iank: It'll keep queuing its own tasks, flush that queue and check
        if resolved promise is done
  iank: If [missed]
  iank: Summary of the engine is, layoutnextfragment()), pushes onto
        internal queue for custom layout instance. Layout engine will
        enqueue a microtask.
  iank: Lay everything out and then queue itself again in case extra
  iank: if it finishes, then... if promise is resolved, then done

  Rossen: So, resolution is to switch back to Promises
  Rossen: Any additional comments or objections?

  eae: Can we add a note about error-handling expectations?
  ACTION: iank to add note about error-handling expectations

  RESOLVED: Use Promises (and add note)

Naming for percentageInlineSize / percentageBlockSize
  github: https://github.com/w3c/css-houdini-drafts/issues/437

  fantasai: Could also do inlinePercentBasis / blockPercentBasis
  iank: This is what you resolve percentage sizes against
  Rossen: “percentResolutionBasis” is kindof what this is about
  Rossen: but that's kinda verbose
  frremy: Issue was that there was some confusion, wanted to make it
          less confusing
  iank: It's easy to guess what the other names are, wanted to keep
        this one consistent
  iank: e.g. availableInlineSize / availableBlockSize
  Rossen: inlinePercentBase / blockPercentBase
  Rossen: Let's close this no change
  Rossen: Get an option more people would be excited about

  RESOLVED: No change

Intrinsic sizes and orthogonal children behaviour
  github: https://github.com/w3c/css-houdini-drafts/issues/776

  iank: I can say what I expect
  iank: I expect that Sizes is the intrinsic size contribution of that
        child in the parent's writing mode
  iank: Different engines will calculate it differently
  Rossen: That sounds overly vague for it to be any kind of definition
          in the spec

  fantasai: You're trying to say that the result of that should be the
            same thing that the layout engine uses for intrinsic size
  fantasai: whether it's shrink to fit on [various things], intrinsic
            size keywords, ...
  fantasai: They should all return the same thing, which is the thing
            returned here, and just be clear about which axis we're
            grabbing from
  fantasai: I think we can put that in the spec, and is definite
            enough to not be vague
  fantasai: It's exactly what we're doing in the sizing spec in a
            number of cases: we don't define how to calculate the
            intrinsic size, but we require it's consistent across all
            the places we use it
  Rossen: I agree

  RESOLVED: Intrinsic size in orthogonal flows are taken according to
            the writing mode of the containing block, and
            intrinsic size calculations have to be consistent with all
            other places in CSS (per CSS Sizing).

Typed OM

  TabAtkins: No open issues to discuss, just a bunch of edits I need
             to make
  TabAtkins: Unless someone has an issue to discuss
  Chris: List of changes, DoC?
  TabAtkins: No
  fantasai: We should get TabAtkins's edits, publish a WD, issue a
            Last Call, wait a few weeks, and then go to CR

  TabAtkins: We have an implementation, one of our engineers is
             working on it.
  Rossen: Firefox?
  heycam: Not of Typed OM
  heycam: Q4 someone should start looking at it for Firefox
  fantasai: Is Blink shipping the implementation?
  eae: Yes

  dino: Does it have benefits? Is it faster?
  TabAtkins: Much faster for animations, e.g.
  shane: Performance numbers in the intent to ship
  tantek: You do that without it being in CR?
  tantek: Without anyone else implementing it? wow.
  shane: Depends on various factors, but yes.

  TabAtkins: Bunch of edits, but biggest task is filling in
             serialization of properties appendix
  TabAtkins: And that's easy for someone else to work on
  Rossen: frremy ?
  frremy: Sure.

  RESOLVED: Add frremy as co-editor on css-typed-om, move nainar to
            former editor

Custom Paint

  fantasai: Wasn't Paint supposed to be a CR?
  [people can't remember what's going on]
  [WD was published:
https://lists.w3.org/Archives/Public/www-style/2018Apr/0036.html ]
  fantasai: Are there any open issues on the spec?
  iank: One open issue.
  fantasai: Then let's close it and go to CR.

Optional arguments in paint functions
  github: https://github.com/w3c/css-houdini-drafts/issues/763

  TabAtkins: Somebody wants optional arguments in paint functions
  TabAtkins: It's a very reasonable request
  TabAtkins: However, this falls under the more general issue of
             optional bits of syntax in custom properties
  TabAtkins: which is currently not allowed because of issues around
             parsing ambiguity
  TabAtkins: So we need disambiguation support first

  florian: Is this a hard problem, or we need to solve it but haven't
  TabAtkins: latter
  TabAtkins: Definitely not impossible
  TabAtkins: Support for more syntax-y things is slated for L2
  fantasai: So proposal is close deferred to next level?
  TabAtkins: That's what I would like
  Rossen: Any other opinions?

  RESOLVED: Deferred to L2


  fantasai: Is there anything else is needed for the spec?
  iank: No
  TabAtkins: TypedOM has changed how it handles image values
  TabAtkins: which might affect this, but it's not affecting this spec

  Rossen: Any objections to taking Paint API to CR?
  Rossen: No? Resolved.

  RESOLVED: Custom Paint to CR

  Chris: DoC? Changes List?
  <dbaron> there were 3 or 4 edits since the last TR version
  <dbaron> https://hg.css-houdini.org/drafts/rev/3a0546211ec0
  [discussion of administrative stuff to get to CR]
  fantasai: I can help IanK make the DoC and stuff

CSS Animation Worklets

  TabAtkins: Nobody is here. Let's skip
  ACTION: iank to move spec to houdini repo


  Rossen: Demos and then lunch?
  Rossen: Or pressure IanK to do edits
  shane: We could spend the afternoon on getting the specs to CR.
  RESOLVED: IanK, shane, Tab, fantasai, and ChrisL to stay the
            afternoon and get specs to CR.

  dino: Other browser implementations of custom layout / paint / etc?
  Rossen: Custom layout only in Blink
  iank: Experimental. Going smoothly, might do an origin trial later
        this year
  iank: If authors like it, don't find any issues, will push for CR.
  heycam: We won't be looking at custom paint or layout this year.
          Pushed to next year
  dino: So everything we've discussed today is only implemented in
        Blink, nobody else. That's scary.
  iank: Paint API is simple to implement.
  dino: Worklet is tricky
  ChrisL: You need worklets for Web audio anyway
  dino: It's all new to us

  dbaron: For us the big obstacle might be TypedOM
  dbaron: Feels like biggest dependency of custom paint
  iank: You can do a stripped down version of Typed OM, which
        everything returns CSS style values, and upgrade up
  iank: People can feature-detect that.
  dbaron: I think that would be fine if we were shipping before you,
          that'd be fine
  dbaron: But if shipping 6mo to 1yr later, then we need to implement
          the same featureset you have, otherwise won't work
  dbaron: One question is whether there should be an alternative in
          the API that doesn't use typed OM
  fantasai: If you're going to do that, why not just use what iank said
  iank: Polyfill we've got out at the moment, doesn't use a whole
        bunch of typedOM stuff
  iank: If you just ship the style value part, should still work

  dino: How many WPT do you have?
  iank: Quite a few
  iank: For layout 80-100, more like 150 by the time we're done
  iank: paint API has 65 atm
  iank: Has a lot grouped in together into one test
  iank: Unsure about typed OM...
  iank: It's got like 4000
  [discussion of tests]

  Rossen: WebKit?
  dino: We'd probably do it in order.
  dino: Clearly we need TypedOM for paint, and also will give a lot of
        immediate improvements for developers
  dino: Other things, unsure how we'll prioritize
  dino: You see articles about people saying how cool Houdini is, but
        not so many people giving loud feedback about how they need
        this particular feature
  dino: Hard to gauge what people want more than anything else
  dino: Dunno how we'd prioritize, other than TypedOM coming first

  Rossen: We're in the same boat
  Rossen: It's going to be a sprint or two for us to put things
  Rossen: Google spent significant time and resources getting to where
          they are
  iank: Main cycles for us were typed OM and worklet infrastructure
  iank: Paint stuff was relatively trivial
  iank: Layout stuff isn't particularly difficult once you've got the
        rest of the infrastructure.
  iank: Reason worklet took so long is because we were waiting for ES6
        modules to land
  iank: So we had working in a few months, but took awhile to get up
        to spec compliance
  iank: If we didn't have the ES6 dependency, would've been a lot
  iank: Paint was just a quarter
  Rossen: Paint seems easiest once you have the infrastructure
  iank: Typed OM was biggest engineering investment
  iank: Paint and layout are trivial after that
  florian: TypedOM was difficult because big, or because churn?
  shane: Both
  shane: We spent a lot of time adjusting spec and implementation in
         response to feedback, which others won't have to do

  Rossen: So, I think summary of implementation status is blink has
          quite a bit ready to go, Firefox has started on some of the
          properties and values, logical next one would be typedOM
  Rossen: WebKit and Edge have not started

  philipwalton: From developer feedback perspective, I don't hear
                people asking for typedOM, I hear a lot of requests
                for paint to animations, and lot for custom properties
  dino: I would've assumed that what people want nowadays is custom
  dino: They write their react code, and want to do everything
  philipwalton: That was my perspective, but some developers want
                that, not everyone.
  philipwalton: You can't polyfill layout, but you can fallback nicely
                for paint stuff
  philipwalton: So that's what developers want now
  philipwalton: The things they can do now, they want to do
  florian: Also, these things can be easy enough that individual
           developers to do it
  florian: But layout is harder, so more likely waiting for a library
           to be developed; fewer individual users
  leaverou: My impression is also what Philip said. Primary concern
            devs have is transitioning and animating custom
            properties, not just via properties and values API

  leaverou: I've presented this API at several talks
  leaverou: The most common question I get is, why do we have to use
            JS for this? Why can't we have it in an @rule?
  florian: Type declarations, you mean?
  leaverou: Yeah
  frremy: Greg and I have been talking with devs. They're mostly
          unhappy about perf and not having proper APIs for things
          they want to do, not trudging through bad APIs
  Rossen: When you compare teams with highly-skilled devs on products,
          they will put anything they want, write their own middle
          layer if they need
  Rossen: Some person supporting small website, won't be writing
          custom layout
  iank: A bunch of things Material Design team wants to do, are easy
        in paint API, very difficult without it

  Rossen: OK. Anything else to discuss for houdini?
  dino: Are we meeting at TPAC?
  dino: Also why do we consider separating the groups because ppl are
        in both of them?
  TabAtkins: Not exactly true
  florian: ... split tracks
  TabAtkins: Yes, should meet at TPAC
  Rossen: I have room for Thursday, we have dedicated
  florian: So effectively 3 days for CSSWG at TPAC

  fantasai: The way we have scheduled this year is super uneven
  fantasai: Expect a lot of topics on the agenda for CSSWG at TPAC

  [Meeting closed]
Received on Wednesday, 18 July 2018 22:08:01 UTC

This archive was generated by hypermail 2.4.0 : Friday, 25 March 2022 10:09:11 UTC