[00:00.000 --> 00:12.000]  Welcome, our next speaker, Nate Willis.
[00:12.000 --> 00:14.000]  Hi.
[00:14.000 --> 00:16.000]  Well, I have good news.
[00:16.000 --> 00:19.000]  The non-font-related portions of the event are now officially over.
[00:19.000 --> 00:22.000]  We can get down to business.
[00:22.000 --> 00:25.000]  Anyway, as Tom implied, I'm Nate Willis,
[00:25.000 --> 00:29.000]  and I'm an impressionable young PhD student from over in the UK.
[00:29.000 --> 00:34.000]  I'm going to talk about a specification that I worked on a couple years ago
[00:34.000 --> 00:39.000]  and how I discovered that choosing a license or the best license for it isn't simple.
[00:39.000 --> 00:45.000]  The options there are scarce, the particulars are real particular,
[00:45.000 --> 00:48.000]  and there isn't much in the way of best practices or guidance,
[00:48.000 --> 00:53.000]  especially if you want the license on a specification to embody free-to-me principles.
[00:53.000 --> 00:57.000]  And I'm also going to try and make the case along the way that
[00:57.000 --> 01:01.000]  even small project specifications like this matter,
[01:01.000 --> 01:04.000]  and therefore this warrants some consideration.
[01:04.000 --> 01:08.000]  Weirdly enough, I think this is the third time I've spoken in the legal policy dev room,
[01:08.000 --> 01:13.000]  but this is not going to be like my first talk in which I gave a lot of information
[01:13.000 --> 01:15.000]  about fonts and things like that.
[01:15.000 --> 01:19.000]  It's going to be a lot more like my second one, which is about photo policies,
[01:19.000 --> 01:22.000]  in the sense that I just rattle off a bunch of stuff, meeting discussion,
[01:22.000 --> 01:25.000]  and then nothing happens.
[01:25.000 --> 01:27.000]  But I have decided that that is science.
[01:27.000 --> 01:30.000]  I was watching this documentary, and there's a reference at the end,
[01:30.000 --> 01:32.000]  just so you can get that cleared up.
[01:32.000 --> 01:35.000]  It's about the research process, and two of the people interviewed
[01:35.000 --> 01:39.000]  brought up this interesting principle, which I'm going to put to the test,
[01:39.000 --> 01:43.000]  which is to say talking about it is at least good enough.
[01:43.000 --> 01:47.000]  And I genuinely want to know, though, what everyone else here thinks.
[01:47.000 --> 01:53.000]  So as we're going, please look deep into your soul.
[01:53.000 --> 01:56.000]  And for the lawyers, I guess, ask someone sitting near you.
[01:56.000 --> 02:00.000]  But I do have to talk about fonts briefly, so you have some context to orient your thinking,
[02:00.000 --> 02:05.000]  because not all specifications and not all projects are going to be the same.
[02:05.000 --> 02:06.000]  So let's go back to the beginning.
[02:06.000 --> 02:10.000]  Back in 2018, I was hired to work in this repository on GitHub,
[02:10.000 --> 02:13.000]  which is a specification for text shaping.
[02:13.000 --> 02:16.000]  Text shaping is something that there's a free software library for called HarpBuzz,
[02:16.000 --> 02:20.000]  which is excellent, but there's some specification for how it's supposed to work.
[02:20.000 --> 02:24.000]  And so this company, YesLogic in Australia, who make document conversion software,
[02:24.000 --> 02:28.000]  were working on their own shaping engine, written in Rust.
[02:28.000 --> 02:30.000]  And the lack of a spec was a huge obstacle.
[02:30.000 --> 02:33.000]  So in our project, I went through the HarpBuzz source code,
[02:33.000 --> 02:38.000]  and I tested Vedad and Khaled and people who work on it with a lot of questions,
[02:38.000 --> 02:40.000]  and wrote a specification.
[02:40.000 --> 02:44.000]  YesLogic, the team then used that to implement their own shaper, AllSorts,
[02:44.000 --> 02:48.000]  which is also open source, we sort of put that to the test.
[02:48.000 --> 02:53.000]  And initially, the goal of writing this in a specification was that we wanted to have open type
[02:53.000 --> 02:59.000]  or some other standards owning organization officially take it up, which didn't happen.
[02:59.000 --> 03:05.000]  So we kept the license out of the repo at that time just to avoid the hassle of having to re-license it,
[03:05.000 --> 03:10.000]  as well as to hammer home the fact that it was unofficial and still a work in progress.
[03:10.000 --> 03:15.000]  Like I said, most of the stuff was 2018 when I wasn't doing anything else.
[03:15.000 --> 03:21.000]  I've continued to make some updates to it, especially when the YesLogic people find a bug or something.
[03:21.000 --> 03:25.000]  But this unlicensedness does need to change.
[03:25.000 --> 03:29.000]  People do find it useful, they cite it even without the license,
[03:29.000 --> 03:33.000]  especially people who work on publishing and font support tools and things.
[03:33.000 --> 03:37.000]  You might be thinking, well, wait a minute, we have open type, we have Unicode,
[03:37.000 --> 03:40.000]  what exactly is the problem here that needs specifying?
[03:40.000 --> 03:44.000]  Well, here's the thing. This is the bit of fonts that I do have to talk about.
[03:44.000 --> 03:50.000]  Unicode defines how a language is encoded, but it doesn't know or say anything about what's inside of a font.
[03:50.000 --> 03:55.000]  An open type defines how fonts are structured, but it doesn't know what's in the document
[03:55.000 --> 03:59.000]  that you might use with that font active.
[03:59.000 --> 04:03.000]  Silicon Valley doesn't want you to know this, but it's the truth.
[04:03.000 --> 04:08.000]  Here's an example. Unicode says every letter has one unambiguous encoding.
[04:08.000 --> 04:14.000]  In an open type font, every time you see that code point, you look it up and it's an A,
[04:14.000 --> 04:18.000]  so you take that bit sequence in the glyph table, you find it, hopefully there's an image of an A,
[04:18.000 --> 04:21.000]  and you put that into the document or on the screen or whatever.
[04:21.000 --> 04:26.000]  However, there are some languages that have exotic behavior like this.
[04:26.000 --> 04:30.000]  Unicode says E with things on top is a different letter than E.
[04:30.000 --> 04:36.000]  And in most cases, the things are also a different encoding code point.
[04:36.000 --> 04:42.000]  So the person who typed that, they might have had that symbol on the left on their keyboard,
[04:42.000 --> 04:45.000]  but they might have actually typed other two things instead.
[04:45.000 --> 04:51.000]  And what if the font has one of those but not the other, or vice versa, or any of those permutations?
[04:51.000 --> 04:56.000]  Some layer in the environment has to make that match and know what to do in that situation.
[04:57.000 --> 04:59.000]  But it's not just exotic languages.
[04:59.000 --> 05:06.000]  There are widely used writing systems like this one where the whole one image per byte sequence code point
[05:06.000 --> 05:08.000]  just isn't enough to get text on the screen.
[05:08.000 --> 05:11.000]  Like when they connect, they can be connecting in arbitrary ways.
[05:11.000 --> 05:15.000]  Remember Unicode says each letter just has one encoding code point.
[05:15.000 --> 05:19.000]  So in those where there's connected multiple images required,
[05:19.000 --> 05:25.000]  OpenType just says just put a bunch of them into your font with the same code point assigned,
[05:25.000 --> 05:29.000]  and then you can put tags on them to say this one's for initial letters,
[05:29.000 --> 05:31.000]  this one's for connecting the middle, and so on.
[05:31.000 --> 05:33.000]  But nothing describes...
[05:33.000 --> 05:38.000]  OpenType doesn't tell you how the software determines that it needs to grab that variant,
[05:38.000 --> 05:42.000]  or this one, or what order to do it in, or how to even know to look.
[05:42.000 --> 05:44.000]  That's what shaping is.
[05:44.000 --> 05:47.000]  It's not in either place, even though both of those standards exist,
[05:47.000 --> 05:50.000]  because it's sort of part of the environment.
[05:50.000 --> 05:52.000]  So that's what we're specifying.
[05:52.000 --> 05:57.000]  And I thought I should say that because for assigning a license for a specification,
[05:57.000 --> 05:58.000]  you didn't know what it is.
[05:58.000 --> 06:00.000]  This means we're defining a behavior.
[06:00.000 --> 06:02.000]  For example, it's not a format.
[06:02.000 --> 06:03.000]  It's not a codec.
[06:03.000 --> 06:07.000]  It's something functional, but it gets down to real specific detail.
[06:07.000 --> 06:09.000]  Like there's regular expressions in there.
[06:09.000 --> 06:11.000]  But it is also a single component,
[06:11.000 --> 06:14.000]  so it's not back and forth like communications protocols
[06:14.000 --> 06:21.000]  are where you have to worry about two implementations talking to each other.
[06:21.000 --> 06:24.000]  Importantly, people need it to be consistent across all implementations, though.
[06:24.000 --> 06:27.000]  Like that's the point of specifying it.
[06:27.000 --> 06:30.000]  Because documents have unbounded lifespans,
[06:30.000 --> 06:33.000]  and they can travel anywhere.
[06:33.000 --> 06:37.000]  So people on both ends want to know if you write an email or a paper or something,
[06:37.000 --> 06:40.000]  and you send it to someone else, regardless of what else they're on,
[06:40.000 --> 06:42.000]  they expect it to look the same.
[06:42.000 --> 06:46.000]  And that kind of means that the specification needs to support proprietary implementation,
[06:46.000 --> 06:49.000]  in addition to free ones.
[06:49.000 --> 06:54.000]  Some of those are factors that would be different in other specifications
[06:54.000 --> 06:57.000]  or other things you could specify or write standards for.
[06:57.000 --> 07:01.000]  There's interoperability tests that matter when you're doing network protocols
[07:01.000 --> 07:03.000]  that aren't really applicable here.
[07:03.000 --> 07:09.000]  For this, when there's a problem, you do that with regression tests and diffs and things like that.
[07:09.000 --> 07:11.000]  So this is worth defining a specification for,
[07:11.000 --> 07:15.000]  because yes, Logic, people are going to write new engines that do it.
[07:15.000 --> 07:18.000]  There's always a new language or a new environment like a game engine
[07:18.000 --> 07:21.000]  or something that has a different stack to it.
[07:21.000 --> 07:23.000]  So the spec seems to work.
[07:23.000 --> 07:24.000]  We want to license it.
[07:24.000 --> 07:27.000]  What do we choose that meets the need?
[07:27.000 --> 07:29.000]  Take a specification license.
[07:29.000 --> 07:31.000]  That'd be great if it existed, ideally.
[07:31.000 --> 07:35.000]  If there was an open specification license or a couple of them, we'd just use that.
[07:35.000 --> 07:38.000]  There's not.
[07:38.000 --> 07:41.000]  In the absence of that, most people seem to just opt for other licenses,
[07:41.000 --> 07:42.000]  which makes sense.
[07:42.000 --> 07:43.000]  It's understandable.
[07:43.000 --> 07:46.000]  I know a little bit about documentation and licenses,
[07:46.000 --> 07:49.000]  so I can talk about some of those generic options.
[07:49.000 --> 07:54.000]  The GNU free documentation license has some pretty inconvenient things in it,
[07:54.000 --> 07:57.000]  like the invariant clause, which people can invoke.
[07:57.000 --> 08:00.000]  Even if I wouldn't assign the invariant clause to things in the specification,
[08:00.000 --> 08:07.000]  the downstream recipient might, and I don't want to imply that burden for other people.
[08:07.000 --> 08:12.000]  The Creative Commons licenses, obviously there's a bunch of those.
[08:12.000 --> 08:16.000]  The restricted ones would not be useful, like non-commercial,
[08:16.000 --> 08:19.000]  but they just address different use cases and ideas, in my opinion,
[08:19.000 --> 08:22.000]  because they're meant for creative and cultural work,
[08:22.000 --> 08:25.000]  which is also true for software licenses applied to standards,
[08:25.000 --> 08:30.000]  like they talk about derivative works in a way that makes sense for executable code
[08:30.000 --> 08:34.000]  or for performing things in the Creative Commons case.
[08:34.000 --> 08:36.000]  But they're always concerned with the document itself,
[08:36.000 --> 08:38.000]  whereas I think in a standard or specification,
[08:38.000 --> 08:41.000]  they want to be clear about the difference between the contents
[08:41.000 --> 08:44.000]  and implementing them in the document itself.
[08:44.000 --> 08:47.000]  Now, the other trivial solution might be just to pick the license
[08:47.000 --> 08:49.000]  that matches what you have to interface with.
[08:49.000 --> 08:51.000]  That's not always easy.
[08:51.000 --> 08:54.000]  I'm going to show you why from our particular case.
[08:54.000 --> 08:55.000]  You think open type.
[08:55.000 --> 08:57.000]  It says open right there in the name.
[08:57.000 --> 08:58.000]  It's an open standard.
[08:58.000 --> 09:01.000]  And if you Google it, you see, oh, there's a URL there.
[09:01.000 --> 09:03.000]  And that's what it looks like.
[09:03.000 --> 09:06.000]  We zoom in on that left column.
[09:06.000 --> 09:08.000]  That's where all the tables are.
[09:08.000 --> 09:10.000]  Enhance.
[09:10.000 --> 09:13.000]  But you see all the stuff in lower case letters there.
[09:13.000 --> 09:17.000]  That's actually from the true type specification, which is there.
[09:17.000 --> 09:20.000]  Let's go back one more time.
[09:20.000 --> 09:22.000]  Enhance.
[09:22.000 --> 09:26.000]  Except for the capital letters, CFF and CFF2.
[09:26.000 --> 09:27.000]  Those are from PostScript.
[09:27.000 --> 09:30.000]  And they live there in PDF form, oddly enough.
[09:30.000 --> 09:32.000]  Then there's also the ISO spec,
[09:32.000 --> 09:35.000]  which is officially what open type actually is.
[09:35.000 --> 09:37.000]  We don't really seem to talk about that very much.
[09:37.000 --> 09:39.000]  And then there's the SFNT spec at the bottom.
[09:39.000 --> 09:41.000]  I know you can't really read the URL,
[09:41.000 --> 09:44.000]  but that's a dead like anyway, so it doesn't matter.
[09:44.000 --> 09:48.000]  Is that convoluted? Yes.
[09:48.000 --> 09:50.000]  The billionaires don't want you to know this.
[09:50.000 --> 09:53.000]  But the reason is it was written by three companies
[09:53.000 --> 09:55.000]  who didn't really want to talk to each other.
[09:55.000 --> 09:57.000]  Their rivals, their implementations are secret.
[09:57.000 --> 10:00.000]  So as little as possible is put into it.
[10:00.000 --> 10:01.000]  And this is not going to go away.
[10:01.000 --> 10:02.000]  This is how it works.
[10:03.000 --> 10:06.000]  This arrangement is what ended the fought wars in the 90s.
[10:06.000 --> 10:09.000]  This is Versailles you're looking at here.
[10:09.000 --> 10:12.000]  Bad news, but that's what it is.
[10:12.000 --> 10:14.000]  On the other hand, Unicode is a lot nicer.
[10:14.000 --> 10:16.000]  Unicode is very straightforward.
[10:16.000 --> 10:18.000]  There are a couple of different licenses
[10:18.000 --> 10:19.000]  applied to different things.
[10:19.000 --> 10:22.000]  It's sort of split up by the URL patterns there.
[10:22.000 --> 10:24.000]  There are a lot of components.
[10:24.000 --> 10:26.000]  Some of these things are in older licenses
[10:26.000 --> 10:28.000]  because they're from much older releases.
[10:28.000 --> 10:31.000]  Committee reports, national standards, things like that.
[10:31.000 --> 10:33.000]  The little stuff is there.
[10:33.000 --> 10:36.000]  The neo-historian capitalists don't want you to know this,
[10:36.000 --> 10:39.000]  but the older material still matters
[10:39.000 --> 10:42.000]  for things like archives and legacy documents and stuff like that.
[10:42.000 --> 10:45.000]  Again, document lifespans don't have an end to them.
[10:45.000 --> 10:47.000]  There's no limit.
[10:47.000 --> 10:49.000]  I don't want to harp on the particulars too much,
[10:49.000 --> 10:51.000]  but I do want to say this happens when we interface
[10:51.000 --> 10:53.000]  with external specifications.
[10:53.000 --> 10:57.000]  Openknight has that weird lateral complexity to it
[10:57.000 --> 11:00.000]  because of the rivals working together.
[11:00.000 --> 11:03.000]  On the other hand, Unicode has sort of longitudinal complexity,
[11:03.000 --> 11:04.000]  you might say.
[11:04.000 --> 11:06.000]  Those are not isolated cases.
[11:06.000 --> 11:09.000]  External standards don't arrive in the form that's ideal for you.
[11:09.000 --> 11:11.000]  You take what you get there.
[11:11.000 --> 11:13.000]  So without a prefab solution,
[11:13.000 --> 11:15.000]  the next thing I did was just sort of dig in
[11:15.000 --> 11:17.000]  to see what other pro-freedom
[11:17.000 --> 11:20.000]  or freedom-adjacent standards publishers do.
[11:20.000 --> 11:22.000]  Here again, the bad thing is that none of them
[11:22.000 --> 11:26.000]  are presenting their license as something off the shelf community,
[11:26.000 --> 11:28.000]  you're free or encouraged to reuse.
[11:28.000 --> 11:30.000]  So this is a bit fake.
[11:30.000 --> 11:32.000]  There's not really a pallet to choose from,
[11:32.000 --> 11:35.000]  but I looked anyway and I want to highlight a couple of these
[11:35.000 --> 11:38.000]  that I think are instructive
[11:38.000 --> 11:40.000]  because there's some good takeaways.
[11:40.000 --> 11:44.000]  The W3C, probably the most freedom-ish of these organizations,
[11:44.000 --> 11:46.000]  they actually have two licenses
[11:46.000 --> 11:49.000]  and they're distinct from each other in some important ways.
[11:49.000 --> 11:52.000]  One of them is the software notice and license,
[11:52.000 --> 11:55.000]  the other is the document license.
[11:55.000 --> 11:56.000]  They're mixed up.
[11:56.000 --> 11:59.000]  A lot of things you'd think would be on one or actually on the other.
[11:59.000 --> 12:02.000]  For instance, the font-related ones are a complete blend.
[12:02.000 --> 12:04.000]  Progressive font enrichment is one of those
[12:04.000 --> 12:06.000]  and incremental font transfer is the other,
[12:06.000 --> 12:09.000]  even though those work together.
[12:09.000 --> 12:11.000]  But some things that are important here
[12:11.000 --> 12:13.000]  is these licenses, particularly the document license,
[12:13.000 --> 12:15.000]  they talk about implementation,
[12:15.000 --> 12:18.000]  so that's already an improvement.
[12:18.000 --> 12:20.000]  On the other hand, the documentation license
[12:20.000 --> 12:22.000]  has a lot of W3C-specific language in it,
[12:22.000 --> 12:26.000]  like it references pointing out the standards track status
[12:26.000 --> 12:32.000]  and a lot of things are about how W3C does its standards.
[12:32.000 --> 12:37.000]  It mentions that you can use code examples,
[12:37.000 --> 12:38.000]  which is useful for my case
[12:38.000 --> 12:40.000]  because of regular expressions and things,
[12:40.000 --> 12:43.000]  but it is hyper-specific in the way that it says that
[12:43.000 --> 12:45.000]  to Web IDL and CSS
[12:45.000 --> 12:48.000]  and things that are declared clearly marked examples.
[12:48.000 --> 12:51.000]  I don't feel like that's general enough for use.
[12:51.000 --> 12:54.000]  This is a long tail of what could be a reusable snippet.
[12:54.000 --> 12:56.000]  The other thing is it knows that you can quote from it
[12:56.000 --> 12:58.000]  in your implementation, which is also really important
[12:58.000 --> 13:00.000]  because people do that.
[13:00.000 --> 13:02.000]  They put quotes in the comment blocks in the source code
[13:02.000 --> 13:04.000]  to explain the intent,
[13:04.000 --> 13:06.000]  and you want that to be non-burden-some,
[13:06.000 --> 13:10.000]  so there's a lightweight notice that you put in W3C case.
[13:10.000 --> 13:14.000]  The other organization we're looking at is the IETF,
[13:14.000 --> 13:17.000]  which its official license has this creepy name
[13:17.000 --> 13:19.000]  that sounds like they meet in a vault
[13:19.000 --> 13:21.000]  in an IETF mansion or something.
[13:21.000 --> 13:23.000]  Some new points here, though.
[13:23.000 --> 13:25.000]  It knows that translation is allowed,
[13:25.000 --> 13:27.000]  which the W3C does not,
[13:27.000 --> 13:28.000]  and that's pretty important,
[13:28.000 --> 13:31.000]  especially if you're dealing with a project like the one I did,
[13:31.000 --> 13:35.000]  which is all about global language support.
[13:35.000 --> 13:36.000]  It also, differently though,
[13:36.000 --> 13:39.000]  it defines the terms of quotation
[13:39.000 --> 13:40.000]  by the length of the document,
[13:40.000 --> 13:42.000]  just one-fifth of the document,
[13:42.000 --> 13:44.000]  which is an interesting distinction.
[13:44.000 --> 13:46.000]  I don't know how great that is.
[13:46.000 --> 13:48.000]  You want those terms to be easy to follow,
[13:48.000 --> 13:50.000]  particularly because the quotes might start out
[13:50.000 --> 13:51.000]  as a paragraph together,
[13:51.000 --> 13:53.000]  but then when you refactor the code,
[13:53.000 --> 13:54.000]  you have to split that up,
[13:54.000 --> 13:56.000]  and if you end up putting a big notice
[13:56.000 --> 13:57.000]  on every single line of that,
[13:57.000 --> 13:59.000]  that's not ideal.
[13:59.000 --> 14:01.000]  A few other things I researched
[14:01.000 --> 14:02.000]  which are not worth getting into.
[14:02.000 --> 14:04.000]  The ISO process is a monstrosity,
[14:04.000 --> 14:05.000]  as you would expect.
[14:05.000 --> 14:08.000]  The whole machinery of international global politics
[14:08.000 --> 14:09.000]  is involved in that.
[14:09.000 --> 14:11.000]  Plus, there are different terms
[14:11.000 --> 14:13.000]  on most of the things they do.
[14:13.000 --> 14:16.000]  OpenAPI, I sort of thought this project that I was on
[14:16.000 --> 14:17.000]  sounded like an API first.
[14:17.000 --> 14:20.000]  It sounds great, but apparently it's actually
[14:20.000 --> 14:22.000]  only about machine-discoverable
[14:22.000 --> 14:24.000]  HTTP application services.
[14:24.000 --> 14:26.000]  I think I quit reading.
[14:26.000 --> 14:28.000]  It's like 15,000 words long.
[14:28.000 --> 14:29.000]  I'm not exaggerating.
[14:29.000 --> 14:31.000]  I counted.
[14:31.000 --> 14:34.000]  There is more written about open standards
[14:34.000 --> 14:36.000]  from the OSI and from a lot of governments,
[14:36.000 --> 14:38.000]  and that actually gets pretty different
[14:38.000 --> 14:39.000]  in most of the talk there.
[14:39.000 --> 14:41.000]  It's not about the licensing of the document.
[14:41.000 --> 14:43.000]  It deals with patents and intellectual property things,
[14:43.000 --> 14:45.000]  which you heard about in the previous session,
[14:45.000 --> 14:47.000]  but it also deals with the process of our time,
[14:47.000 --> 14:49.000]  like who decides who is participating,
[14:49.000 --> 14:51.000]  how do you make and publish updates.
[14:51.000 --> 14:52.000]  That's about it.
[14:52.000 --> 14:54.000]  That's as much about the standards body
[14:54.000 --> 14:55.000]  as the specification itself,
[14:55.000 --> 14:57.000]  and it gets into deep questions about the difference
[14:57.000 --> 14:59.000]  between standard and specification.
[14:59.000 --> 15:01.000]  For our project, the GitHub repo participation
[15:01.000 --> 15:02.000]  is pretty wide open.
[15:02.000 --> 15:04.000]  We've had a loose, low-impact method
[15:04.000 --> 15:05.000]  incorporating changes,
[15:05.000 --> 15:07.000]  but that's because we're piggybacking
[15:07.000 --> 15:09.000]  on the way the GitHub site works,
[15:09.000 --> 15:11.000]  and we're kind of limiting that
[15:11.000 --> 15:13.000]  by virtue of not having a license assigned.
[15:13.000 --> 15:14.000]  That's what we thought.
[15:14.000 --> 15:16.000]  I did also look at some other things,
[15:16.000 --> 15:18.000]  like the Zife.org, A.B. Codex,
[15:18.000 --> 15:20.000]  which are software licenses,
[15:20.000 --> 15:21.000]  and some things like that,
[15:21.000 --> 15:23.000]  like programming languages that tend to have
[15:23.000 --> 15:25.000]  their own unique license.
[15:25.000 --> 15:28.000]  There's really too much there to generalize from.
[15:28.000 --> 15:30.000]  So if there's not enough shop answer,
[15:30.000 --> 15:31.000]  I guess we're cooking one.
[15:31.000 --> 15:33.000]  So the question is what we like to see.
[15:33.000 --> 15:36.000]  I made a list of these.
[15:36.000 --> 15:38.000]  Big license doesn't want you to know this,
[15:38.000 --> 15:41.000]  but you can do that.
[15:41.000 --> 15:43.000]  The first couple of things that are pretty obvious.
[15:43.000 --> 15:46.000]  Distribute it whole and apart.
[15:46.000 --> 15:48.000]  Implementation, we want to be clear
[15:48.000 --> 15:49.000]  that that's not the same thing
[15:49.000 --> 15:53.000]  as reproducing the text itself.
[15:53.000 --> 15:55.000]  Modifications is trickier, right?
[15:55.000 --> 15:56.000]  Like this open question,
[15:56.000 --> 15:59.000]  because it ties into the participation model stuff.
[15:59.000 --> 16:01.000]  Anyone can make a fork,
[16:01.000 --> 16:03.000]  pull a quest on GitHub, that's good,
[16:03.000 --> 16:05.000]  but we don't want there to be a whole bunch
[16:05.000 --> 16:07.000]  of incompatible things floating around.
[16:07.000 --> 16:10.000]  That connects to stuff like trademarks
[16:10.000 --> 16:13.000]  and how you manage the can and the city of your document.
[16:13.000 --> 16:15.000]  The end there is the stuff that is,
[16:15.000 --> 16:17.000]  I think, maybe more interesting and in a practical sense.
[16:17.000 --> 16:20.000]  The quotation issue, I'm split on that.
[16:20.000 --> 16:22.000]  W3C defines it by purpose.
[16:22.000 --> 16:25.000]  It's in the implementation section.
[16:25.000 --> 16:26.000]  It's a lot of separate green.
[16:26.000 --> 16:29.000]  ITF says it's about length.
[16:29.000 --> 16:32.000]  I'm not sure that I think one of those
[16:32.000 --> 16:34.000]  is better than the other,
[16:34.000 --> 16:36.000]  particularly with posting the notices
[16:36.000 --> 16:37.000]  and rearranging things.
[16:37.000 --> 16:39.000]  Should you do that at the file level?
[16:39.000 --> 16:41.000]  I don't know.
[16:41.000 --> 16:43.000]  Same thing with the quotations of code
[16:43.000 --> 16:45.000]  that people might reuse.
[16:45.000 --> 16:47.000]  Should there be a separate license?
[16:47.000 --> 16:48.000]  Python license does that.
[16:48.000 --> 16:50.000]  It specifies that code snippets are,
[16:50.000 --> 16:52.000]  or should you bake that into the license?
[17:09.000 --> 17:12.000]  Thank you.
[17:39.000 --> 17:41.000]  Thank you.
[18:09.000 --> 18:12.000]  Thank you.
[18:39.000 --> 18:42.000]  Thank you.
[19:04.000 --> 19:07.000]  Okay, check one, two.
[19:08.000 --> 19:10.000]  And we're back on the air.
[19:10.000 --> 19:13.000]  Okay, thank you, Tom.
[19:13.000 --> 19:15.000]  Thank you, other guy whose name I don't know yet,
[19:15.000 --> 19:17.000]  but we'll meet later.
[19:17.000 --> 19:19.000]  Yes, so, okay.
[19:19.000 --> 19:21.000]  I wrote things in pseudo code
[19:21.000 --> 19:23.000]  because I wanted people to implement it themselves.
[19:23.000 --> 19:25.000]  You can't do that with a regular expression.
[19:25.000 --> 19:27.000]  That's what makes them regular expressions.
[19:27.000 --> 19:29.000]  But where do you draw the line there?
[19:29.000 --> 19:31.000]  There's things like state tables.
[19:31.000 --> 19:34.000]  The representation of that is not the mark-downness.
[19:34.000 --> 19:36.000]  It's the actual table.
[19:36.000 --> 19:39.000]  So it's worth thinking about exactly how you
[19:39.000 --> 19:41.000]  specify code and functional things
[19:41.000 --> 19:44.000]  that people could use in their implementation.
[19:44.000 --> 19:46.000]  Anyway, and like I said,
[19:46.000 --> 19:48.000]  there's a few things not discussed here,
[19:48.000 --> 19:50.000]  like patent and IP grants.
[19:50.000 --> 19:52.000]  In my own project, we avoided that
[19:52.000 --> 19:54.000]  because we're sort of covered by
[19:54.000 --> 19:56.000]  implementing open-type and Unicode.
[19:56.000 --> 19:58.000]  Other projects might not be.
[20:02.000 --> 20:04.000]  Let me go back one.
[20:04.000 --> 20:06.000]  Anyway, this is where I'm leaving it.
[20:06.000 --> 20:08.000]  As it is, I guess we're going to put
[20:08.000 --> 20:10.000]  our own license together. I don't know.
[20:10.000 --> 20:12.000]  That might be a whole debate worth it.
[20:12.000 --> 20:14.000]  If I have missed some obvious solution,
[20:14.000 --> 20:16.000]  please, please tell me.
[20:16.000 --> 20:18.000]  I'd like this to be easier in the future
[20:18.000 --> 20:20.000]  for future specificators.
[20:20.000 --> 20:22.000]  It's surprising that this is
[20:22.000 --> 20:24.000]  not a topic that comes up often,
[20:24.000 --> 20:26.000]  even though I guess I'm saying
[20:26.000 --> 20:28.000]  that it does happen. We just don't talk about it.
[20:28.000 --> 20:30.000]  There's a lot of things like on
[20:30.000 --> 20:32.000]  free desktop.org.
[20:32.000 --> 20:34.000]  Kind of specifications,
[20:34.000 --> 20:36.000]  but we don't necessarily think of them
[20:36.000 --> 20:38.000]  that way. We don't think that
[20:38.000 --> 20:40.000]  D-Bus or AppStream or something
[20:40.000 --> 20:42.000]  needs to have all this
[20:42.000 --> 20:44.000]  furniture around it
[20:44.000 --> 20:46.000]  because it's sort of like
[20:46.000 --> 20:48.000]  flying by at the sea that are pants.
[20:48.000 --> 20:50.000]  There's always going to be
[20:50.000 --> 20:52.000]  new bits of technology
[20:52.000 --> 20:54.000]  from the community that have this issue.
[20:54.000 --> 20:56.000]  Let me jump ahead there.
[20:56.000 --> 20:58.000]  Anyway, that's my time.
[20:58.000 --> 21:00.000]  Do get in touch.
[21:00.000 --> 21:02.000]  You can actually visit the
[21:02.000 --> 21:04.000]  GitHub repo, the third link down there.
[21:04.000 --> 21:06.000]  The license thing is a pinned
[21:06.000 --> 21:08.000]  issue, so you can go look at it.
[21:10.000 --> 21:12.000]  Here are the citations I mentioned
[21:12.000 --> 21:14.000]  earlier from the actual screenshots
[21:14.000 --> 21:16.000]  and things.
[21:16.000 --> 21:18.000]  That's where I'm leaving it. Thank you
[21:18.000 --> 21:20.000]  for your attention. Thanks for having me back
[21:20.000 --> 21:22.000]  for the third time.
[21:22.000 --> 21:24.000]  Thank you very much.
[21:30.000 --> 21:32.000]  Thank you.