Farwest Demo
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Subtitle |
| |
| Title of Series | ||
| Number of Parts | 490 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/47023 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FOSDEM 202033 / 490
4
7
9
10
14
15
16
25
26
29
31
33
34
35
37
40
41
42
43
45
46
47
50
51
52
53
54
58
60
64
65
66
67
70
71
72
74
75
76
77
78
82
83
84
86
89
90
93
94
95
96
98
100
101
105
106
109
110
116
118
123
124
130
135
137
141
142
144
146
151
154
157
159
164
166
167
169
172
174
178
182
184
185
186
187
189
190
191
192
193
194
195
200
202
203
204
205
206
207
208
211
212
214
218
222
225
228
230
232
233
235
236
240
242
244
249
250
251
253
254
258
261
262
266
267
268
271
273
274
275
278
280
281
282
283
284
285
286
288
289
290
291
293
295
296
297
298
301
302
303
305
306
307
310
311
315
317
318
319
328
333
350
353
354
356
359
360
361
370
372
373
374
375
379
380
381
383
385
386
387
388
391
393
394
395
397
398
399
401
409
410
411
414
420
421
422
423
424
425
427
429
430
434
438
439
444
449
450
454
457
458
459
460
461
464
465
466
468
469
470
471
472
480
484
486
487
489
490
00:00
DatabaseLogicDemo (music)DemosceneEmulationRight angleCoefficient of determinationRule of inferenceData storage deviceProjective planeCellular automatonGoodness of fitLecture/Conference
00:43
Demo (music)DemosceneSoftware frameworkErlang distributionStandard deviationModul <Datentyp>Template (C++)HypermediaType theoryForm (programming)Operations researchBlock (periodic table)BuildingClient (computing)Computing platformFormal languageLibrary (computing)EmailLink (knot theory)Router (computing)Skeleton (computer programming)Dependent and independent variablesReverse engineeringClient (computing)HypermediaLink (knot theory)Projective planeDependent and independent variablesEmailDifferent (Kate Ryan album)ParsingType theoryErlang distributionFlow separationFunctional (mathematics)Router (computing)FacebookFormal languageDirection (geometry)Standard deviationOperator (mathematics)Finite-state machineRepresentational state transferModule (mathematics)Library (computing)Block (periodic table)BuildingFile formatSoftware frameworkCodeTemplate (C++)Server (computing)State of matterProduct (business)Computing platformRule of inferenceProcess (computing)Power (physics)Electronic signaturePrincipal idealOptical disc driveArchaeological field surveyOrder (biology)MereologyTwitterMultiplication signBit rateDisk read-and-write headMathematicsComputer animation
06:49
Bit rateDependent and independent variablesForm (programming)Skeleton (computer programming)Erlang distributionBinary fileFunction (mathematics)HypermediaoutputMilitary operationTemplate (C++)Link (knot theory)Magneto-optical driveOperations researchComputer configurationSemantics (computer science)CloningDemosceneType theoryProcess (computing)Table (information)Server (computing)Representation (politics)State observerInformationTerm (mathematics)Convex hullOptical disc driveCondition numberFunctional (mathematics)Link (knot theory)Presentation of a groupPoint (geometry)WeightEmailInformationRevision controlWeb 2.0Binary codeSource codeForm (programming)RootStreaming mediaElectric generatorType theorySemantics (computer science)Information retrievalKey (cryptography)VarianceTablet computerProcess (computing)State of matterPower (physics)WebsiteState observerBinary fileCASE <Informatik>Bit rateData managementComputer clusterAreaRing (mathematics)Set (mathematics)Row (database)Group actionDefault (computer science)Operator (mathematics)Representation (politics)Function (mathematics)Web browserHypermediaTerm (mathematics)Template (C++)Line (geometry)Associative propertyOcean currentField (computer science)Demo (music)AutomationEmbedded systemString (computer science)Module (mathematics)File formatMedical imagingDifferent (Kate Ryan album)Computer animation
12:54
Link (knot theory)Server (computing)Template (C++)DemosceneEmulationEmailLink (knot theory)Descriptive statisticsServer (computing)Point (geometry)Time zoneGreatest elementDigitizingCountingScripting languageArmTable (information)InformationOrder (biology)Term (mathematics)Bit rateSubsetTemplate (C++)TupleFlow separation
14:59
Type theoryHypermediaOperations researchFunction (mathematics)Term (mathematics)DemosceneDescriptive statisticsCASE <Informatik>Term (mathematics)Functional (mathematics)EmailTable (information)String (computer science)Template (C++)Finite differenceComputer animation
15:57
Binary fileTupleObject (grammar)String (computer science)ParsingElectronic mailing listUnicodeDemosceneControl flowCache (computing)Operations researchFinitary relationLink (knot theory)WebsiteDependent and independent variablesTemplate (C++)Data typeReading (process)Numbering schemeForm (programming)Semantics (computer science)Client (computing)Erlang distributionFunction (mathematics)Demo (music)Template (C++)Dependent and independent variablesMereologyData storage deviceFunctional (mathematics)EmailField (computer science)Electric generatorTerm (mathematics)Service (economics)File formatForm (programming)Semantics (computer science)Client (computing)OctahedronOperator (mathematics)Multiplication signComputer animation
18:20
Demo (music)Client (computing)Electronic mailing listWeb pageInformationInteractive televisionRight anglePhase transitionTable (information)Group actionNumbering schemeMereology2 (number)Game theoryLecture/Conference
21:04
FacebookPoint cloudOpen source
Transcript: English(auto-generated)
00:05
It's a pleasure to be organizing this Dev Room. It's the first year of an Elixir deadline for our friends, the Dev Room. Before announcing the speaker, we'll be having an after-party at Brewdog at 9 p.m.
00:21
So if you want to join us, you're welcome. We'll surely be talking about the Beam and some very geeky stuff. Our first speaker is Loic, butchering the name right off the bat. He's the creator of cowboy, which probably 99.9% of us have used.
00:42
He's going to talk about his new project, Far West. Loic, take the stage. Thank you. You may have heard of Far West project that I started a few years ago.
01:01
That went with one project in production and then was completely shelved. So this Far West project is what happened after I sought for a few years and finished and decided starting with experimentation.
01:24
Far West is a framework that applies the H2AS principles. So basically what this means is that the server will send everything the client needs to perform any operations it needs.
01:43
So the client doesn't have any knowledge of the server except a few things that we will see. Everything is based on standards as much as possible. So for REST APIs and frameworks, there's always some holes in the standards
02:02
that you have to fill yourself. It's a little difficult at times, but it's getting better. And it's built on top of cowboy. So what it means is that there's the cowboy server, then cowboy REST, which is an HTTP state machine,
02:24
and then Far West on top that drives this state machine directly. So there are a few building blocks. So you have the resource modules. So that's the Erlang code that you will find.
02:42
You have URI and URI templates. So that's how you know which resource you want to access. You have media types, of course. And you have operations. So in HTTP, you have methods like GET, PUT, POST.
03:01
But then you have this POST method, which does many things at once. It can do pretty much everything you want. So in Far West, there's a small concept of operations on top of methods that allow us to define, for example, append, replace, things like this.
03:25
And then you have metadata, for example, for caching resources, for providing signatures, and so on.
03:40
Far West is not only a server, but also client libraries. So currently, I only target Erlang and all the BIM languages. But in time, I want to have one client per language or platform,
04:02
depending on what's the most appropriate. And this one client should be the only one you need to access any API written using Far West. So you don't need to have, for example, if GitHub and Facebook were both using Far West,
04:25
you would not need to have a separate client for GitHub and a separate client for Facebook. And so I'm not writing a separate HTTP client.
04:41
I'm writing just helper functions that you can use with existing clients. So it should be usable with the client you already are using. So far, I've mostly been working on putting links everywhere, basically.
05:06
So there's an HTTP header that is called the link, which is standard. And it's basically the counterpart of the HTML link element.
05:25
And then you have also links in the response bodies. So the links in the headers would be links between the resource you access and directly related documents.
05:44
And in the response bodies, you can have more fine-grained links. I'm using URI templates, so that means I had to write a new router.
06:00
cowboy has its own router, but it's not using a standard format. So I wrote parser for URI templates and then a router based on this. I'm thinking of moving cowboy to this router in a future release as well.
06:21
Variants. There's a problem when you access a resource, which is that you don't know what media types the resource will serve. So variants will tell you the different media types you have, the different languages, and so on.
06:43
And yeah, I started with a very barebone client library for now. And then for convenience, I wrote some HTML generation.
07:03
So by default, well, with very little code, you can have an HTML version of your API. So you could test it with a browser like a normal website. It has skeleton forms. That means that if I have a document and I want to edit it, I have to edit the document as a whole.
07:26
There's no one field per value currently. And I also have a binary format that is much easier to process by automated clients.
07:41
And currently, it's based on a long binary format. So when you write a resource module, you will start by giving a URI or a URI template. So I will show some examples. You also define what operations are available.
08:01
So usually, you will have GET, maybe PUT, maybe DELETE. You also want to associate different media types to your operations. So for example, GET will output text HTML, and PUT will accept maybe an image PNG.
08:28
And links. So you can define links between the documents. And the operations, as I mentioned, are configurable, even though I did not do much in this area yet.
08:43
So you can basically configure the HTTP method at this point. But in the future, all the semantics will be configurable. So you would be able to create as many operations as you need. So there's a demo available online.
09:02
It doesn't show very well, but that's OK. So this is how you would describe your resource module.
09:20
So URI can be a normal URI or a template. So in this case, it's entry point, just search. You define media types, but here you only define aliases. So it's simply easier to refer to HTML instead of the string.
09:45
And then you define your operations. So this resource only does GET, and it outputs HTML and the binary along format. And then you have links.
10:01
When you link with Far West, you never need to give the URI. You simply give the resource module you are linking to, and Far West will get all the information it needs. So here we link to two child resources.
10:23
And this gives us this when you look at the headers. So you have the link header, the big three lines header, with two links we defined, one, two processes, and one, two tables. And for each link, you can see the variance,
10:46
which gives us what media types are provided by this resource. And so currently variance, it's not a standard, it's a draft.
11:01
So that's why it's variance-06. And for the resource itself, you have also variance, which tells you it can give you HTML or bed, and currently, variance key, you receive HTML.
11:24
And so then you would implement the GET function that retrieves data you will convert into a representation. And so this demo, it's basically observer, the long observer tool, a web version of it.
11:47
So we get the information and we return it. We don't do any formatting at this point. Then Far West will keep this data, and when it needs to convert it to a representation,
12:00
it will call the function toRepresentation. And here you can see the HTML embed. So these are the media types you will need to convert this data to. And currently, so there's an automated HTML generation,
12:23
so that's Far West HTML from term here. And this gives something like this, so it's not very pretty currently, but you have all the information that you also have in observer.
12:40
And all this HTML is generated. And at the top, you have the toolings that we saw before, so it gives a small navigation. It's enough for an IPA anyway, but it's not exactly the best user experience currently.
13:07
And then similarly on a different resource, so if we follow the tables link, we also have the link header at the bottom with the link to the parent, the first resource we saw.
13:21
And then separate header Far West link templates. And here I give the templates to the children of this resource. And this resource, it's a table of ETS tables. And so the template refers to all the links that you have on the left here
13:44
to access all the ETS tables. And I had to do a separate header because the link header does not accept link templates. Otherwise, it works more or less the same. And if we continue, oh yeah, first.
14:04
So these links in the body are created automatically. In the long term that we give to Far West, we use a special tuple Far West link.
14:20
And here again, we never link to a URI. We tell Far West to create a link to our resource. And we give some information to fill the URI template values.
14:42
And so this is the table ROM server. And here you can see at the bottom, there's already a button. It's cut off, but delete. And we have all the values in the table.
15:01
And the description looks like this in this case. When you click on one of the values, you will reach a resource that is described like this. The URI template at the top with the table name and the key.
15:25
So that's the value that you want to access. And you have different operations. So you have get, which outputs HTML in this example, and put, which takes a term. And the term, it's this, a long term written as a string.
15:46
And delete doesn't take anything. And so this gives us this. You can edit it, add a zero, and it will update the data automatically. And it does so by calling this function, put. So for each operation, you will implement one function.
16:03
And this function takes the request body, converts it, and stores it in ETS. And similarly for delete, we take what we want to delete and we call ETS delete.
16:20
Okay. And so there's a lot of work left, especially around discovery, because it's a big first part that I want to get right. There's a lot of questions. You have some of them here. Of course, the most important is getting caching, because otherwise you won't get good performance from the API.
16:47
For generating response bodies, I want to provide the ability to use templates instead of generating everything. And so we would be able to replace only some specific templates.
17:00
And of course adding more formats automatically generated. And then there's a big second part, which is semantics. So the first part, we will know what resources are and how to access them. And the second part, we want to know exactly what values in our data we want to use.
17:24
For example, if I have a person, I want to know their name, their email. I need to be able to do so without knowledge of the service. So that will be the big second part. And so probably using schemas, but yeah, there's a lot of research to be done there.
17:45
And once we have this, we can generate forms with many fields instead of having the bigger long term. And also, yeah, generate, like, expand your templates.
18:03
Clients, improving the client, nothing much to say. And that's it. So if you want to try it, you are welcome to send me a lot of emails. I'm looking for adopters. And yeah, thank you.
18:27
Any questions? It's for cowboy. What? Thank you for cowboy. Yeah. Thank you for cowboy. No problem. The schema and stuff like this, will you also transfer automatically if the schema is wrong, something like that?
18:46
So it would have, yeah, it's about schemas. So the schema would have to be transferred in some way, provided by the API at least. But the client probably needs to know at least some things about the schema.
19:09
For example, if you write a client to manage users, all the interaction doesn't need any beforehand knowledge, but you need to know what you are doing with the data.
19:24
Any other question? You mentioned briefly schemas. Can you comment more on that? Yeah, so can I comment more about schemas? So the idea is that currently I serve data, and you don't know what is inside the data without manually looking at it.
19:52
With schemas, you would be able to map the data and retrieve the information you want. For example, if you have the page with the list of ETS tables, with schemas, we would be able to say inside the document, this is an ETS table.
20:11
So we don't need necessarily to follow the link, because maybe the data we want is inside this document.
20:23
So this is what it's about. It's like for modelling data, like finding a principle to the finding data? Yeah, the first phase is finding the data, and the second phase is modelling, accessing, manipulating it.
20:45
For now, I want to get everything else right before, because that's a very big subject. Any other questions? Okay, thank you.