A minimal pure object-oriented reflective language
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 |
| |
| 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/46912 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FOSDEM 2020143 / 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
Programming languageProgramming languageSound effectDigital photographyGrass (card game)Lecture/Conference
00:28
Source codeProcess (computing)AerodynamicsSoftwareComputer programmingElement (mathematics)MereologyCoefficient of determinationSpecial unitary groupDigital photographyIntegrated development environmentStaff (military)Programming languageSoftware developerLecture/ConferenceComputer animation
01:06
SoftwareSource codeComputer animation
01:20
Model theoryObject modelProgramming languageObservational studyObject-oriented programmingComputer animation
01:44
Object modelComputer animation
01:57
Dynamical systemInstance (computer science)Virtual realityAttribute grammarModel theorySingle-precision floating-point formatInheritance (object-oriented programming)Order (biology)Object-oriented programmingRule of inferenceInstance (computer science)Physical systemFunction (mathematics)System callAttribute grammarSocial classType theoryComputer animation
02:38
SubsetVirtual machineProgramming languageSource codeRun time (program lifecycle phase)Coefficient of determinationDigital photography
03:06
Object-oriented programmingImmersion (album)Digital photographyCodeReflection (mathematics)Object-oriented programmingSemiconductor memoryComputer animation
03:37
Social classObject-oriented programmingImmersion (album)Reflection (mathematics)Message passingSocial classComputer programmingComputer animation
03:54
Object-oriented programmingMessage passingPhysical systemObject-oriented programmingPolymorphism (materials science)Real numberAreaComputer animation
04:11
ImplementationPolymorphism (materials science)Rule of inferenceComputer animation
04:25
ImplementationPhysical systemBoolean algebraLogische ProgrammierspracheSource codeRevision controlUser interfaceType theoryPrimitive (album)Fluid staticsOperator (mathematics)Programming languageSocial classMessage passingObject-oriented programmingDevice driverPhysical systemIntegrated development environmentGraph coloringImplementationStructural loadPower (physics)UsabilityInstance (computer science)Constructor (object-oriented programming)User interfaceSoftware developerVertex (graph theory)Different (Kate Ryan album)Dependent and independent variablesType theoryBoolean algebraSource codeComputer animation
05:52
Presentation of a groupComputer configurationRepresentation (politics)Object-oriented programmingVisualization (computer graphics)ResultantCodePower (physics)Software frameworkMatrix (mathematics)Observational studyWorkstation <Musikinstrument>Degree (graph theory)Right angleAreaXMLComputer animation
06:43
Moment of inertiaObject-oriented programmingDirectory serviceComputer fileSystem callComputer animation
07:04
Meta elementReliefData dictionarySource codeImplementationPower (physics)Multiplication signInstance (computer science)Visualization (computer graphics)Software developerPhysical systemMessage passingView (database)Process (computing)Video gameDemosceneLocal ringWorkstation <Musikinstrument>Extension (kinesiology)Integrated development environmentComputer animation
08:06
DebuggerSource codeComputer wormExecution unitDebuggerIntegrated development environmentMathematicsCoefficient of determinationLimit (category theory)Real numberMathematical analysisQuicksortEmailComputer virusComputer animationSource code
08:54
Programming languageDebuggerInterpreter (computing)Physical systemPlanningVolume (thermodynamics)Digital photographyComputer animation
09:35
Computer networkSocket-SchnittstelleComputer programmingComputer programmingInternet der DingeCartesian coordinate systemWeb 2.0Computer animation
09:58
AreaInternet service providerComputer animation
10:13
Programming languageProgramming languageIntegrated development environmentVideo gameMultiplication signComputer programmingHand fanPower (physics)FamilyComputer animation
10:41
Electronic mailing listGroup actionCurve fittingGroup actionFreewareLatin squareDifferent (Kate Ryan album)Computer animationPanel painting
11:13
Copenhagen interpretationInvertible matrixReflection (mathematics)Social classObject-oriented programmingComputer animation
11:28
Enterprise architectureOpen sourceLevel (video gaming)Content (media)
11:47
Open sourceTelecommunicationCore dumpXML
12:03
TelecommunicationSlide ruleGoodness of fitEmailExpert systemElectronic mailing listDynamical systemCausalitySource code
12:36
Multiplication signSet (mathematics)Different (Kate Ryan album)Level (video gaming)Computer animation
12:54
Computer wormMereologyCartesian coordinate systemGoodness of fitMultiplication signProduct (business)Computer animation
13:23
Web 2.0Complex (psychology)Cartesian coordinate systemInternet der DingeComputer animationProgram flowchart
13:43
Process (computing)Source codeDampingPresentation of a groupMultiplication signCodeBuildingControl flowDigital photographyComputer animation
14:31
Primitive (album)CodeInformationProgramming languageEquivalence relationMessage passingIntegerNumberOrder of magnitudeObject-oriented programmingPoint (geometry)Virtual machineMultiplication signCASE <Informatik>Queue (abstract data type)Forcing (mathematics)ForestRhombusFamilyUniform resource locatorLecture/Conference
16:26
Point cloudFacebookOpen source
Transcript: English(auto-generated)
00:05
Good morning, this talk is Faro, the idea is presenting Faro, that is not a new language, but it still is a minimal, pure-object -oriented, reflective language that is quite small in itself, but is very powerful because on top of it we have created a lot of things.
00:25
This talk was intended to be presented by Stéphane Ducasse, but I am not Stéphane Ducasse, sorry, he has a problem with arriving here with the trains in France, we are in the middle of a really big strike, it's not a problem at all, but sometimes makes things a little more difficult.
00:47
Well, I am Paolo Desone, I am one of the engineers working in the Faro Consortium, basically I am working also in the development of Faro with Stéph, so I want to present it, I think it will not be the same but I will do the best that I can.
01:05
Well, Faro, what is Faro? Well, Faro is a small talk inspired language and environment, and it's not new, but this question is always, we have it, why to use Faro? Yes, Faro.
01:21
Because for us, the most important thing, and the thing that we want to share with you, because we see that you are also a language enthusiast, and you like a lot the simplicity and the elegance of the language, is that it's elegant, and it's a really small syntax, we can write the syntax in a postcard, and it has a simple but powerful object model.
01:44
This is the whole syntax of Faro, sorry if some of the details will not be able to be seen, but this is it, this is the full syntax, we only have this, and with this, we have a pretty nice object model on top of
02:02
it, basically dynamically type system, where everything is an object, everything is an instance of a class, and the class also are objects. Also, we have, our old methods are public, we don't have the idea of private methods, they are
02:21
virtual, so they are automatically executed from the subclasses, and we can have override without caring at all. All attributes are protected for us, and we are using single inheritance, and with a small asterisk there, that I will talk later. Faro is fully writing in itself, all they call Faro is bootstrapped from the sources, even the virtual machine is
02:47
mostly writing in a subset of Smalltalk, a subset of Faro, and we can modify everything in the language itself, in the runtime, even during we are executing it, so it's so flexible to change or improve it, or even destroy it.
03:07
Faro also is highly immersive, what we want to say with this, that in Faro, nothing is a black box, you can check the code of all the methods, modify them, and improve it, or do it worse, but the important thing is that we can always learn from that, and get new ideas.
03:25
It's fully inspectable, we can check all the objects in the image, all the objects in the memory, and we can change them, and they have a lot of reflective API to modify. Also, you can interact with all the objects, and classes, and methods, and also objects, you can take
03:44
a class and inspect it, or send messages to modify it in your program, and do nice reflective things. As I told you before, we only have objects and messages, it's a real pure object-oriented world, and everything
04:04
that we have in the system are based in objects, and we use a lot the polymorphism to implement the stuff. For example, if we want to implement not, we have a false not, it should return true, and true not should return false, we let the receiver decide, we will use it doing a polymorphism.
04:27
So, for example, we will have three classes, one for the whole boolean with the common behavior, but one for false, and one for true, because as every object, even true and false are instances of a class, the behavior of true and false are in their respective classes.
04:42
And this is the implementation. And this is not just a theoretical thing, if you check in the system, if you inspect the methods, and check the source code of them, and to modify, this is the implementation. So, with this not-so-much concept, we have a very powerful language and environment that basically does not
05:05
have a lot of the things that we see in many object-oriented languages, or mainstream object-oriented languages. Because, for example, we don't need the idea of constructor, because basically a constructor for us is sending a message to a well-known object, usually a class.
05:20
Or, well, we need a node type declaration, as it's a dynamically typed language, we don't need interfaces, or type factories, or different solutions, because of the type system we are using. The idea of having different visibilities for us is not important, because basically we want to give
05:41
the power to the developer, and if the developer wants to send a message, he should be able. At the end, it's responsible or not for breaking or making the things work. Also, a nice thing that we have in Faro is that as we have everything as an object, we have the idea of customizing the representation of objects, and have nice inspectors on top of it.
06:04
Basically, what we can do on all the objects is that we can execute code directly, interactively, and with this, see the different results. For example, we can take and re-implement how every object is visualized, and it's so easy of doing
06:22
this that we can, for example, integrate with a powerful visualization framework that we have that is called ROSL. We say, okay, for this object, we will represent it in this way, or we will have it represented as an array. At the end, the matrix Q is an array of arrays, but we can implement it in more beautiful things.
06:44
For example, if we inspect a directory, there is an easy implemented way of presenting it as an explorer of this directory. For example, if you inspect one file reference that is an image, it just shows the image in the inspector.
07:03
This also goes for all the objects that we have, and objects that are not usually accessible. For example, in this one, we are inspecting a method from a method dictionary in the class, one of the methods that we'll execute when we are executing or sending messages to instances of dice handles, so they will have this implementation of plus.
07:26
From the compile method we are inspecting, we have many views, but one is to see the AST node, and as this is an AST node, someone has took the time and said, okay, I will do an extension, but every time you are inspecting the AST node, I will provide a
07:43
new view that just shows the source code of the method and highlights the node that you are selecting. This gives a lot of power to open the system and create new visualizations and new tools in an easy way.
08:00
Because as we are developers, we think a lot about how to have a faster development process. And one thing that I really love about Fado is that it is a live programming environment. You can basically develop in the debugger. This is our base debugger, where you can execute Go and do debugger stuff, but also you can come here and modify this method,
08:25
and once you modify the method, it will recompile the method, and you can restart the execution from there. If you recompile the method, of course it will restart from the beginning of the method, it will not do the analysis to see the changes and restart in the middle, but it's powerful enough to do a real nice TDD experience, because you can really create the test and let all the other methods empty,
08:49
and you start debugging it until you provide the smallest solution possible. A nice other thing that we have is that this debugger is basically as moldable as everything else in the system.
09:02
So for example, one of the users of Fado has implemented, using the same debugger, a debugger that, this is a language called Viena, if I remember well, and they have implemented an interpreter in Fado, but debugging the interpreter is boring and takes a lot of work, so they have
09:23
created a debugger on top of the debugger to debug the language of the interpreter. So this ability to create new tools and to inspect objects, we can do it not only for developing the Fado itself and tools for Fado,
09:41
but also we do it or we try to sell to you and to everyone that live programming can be something that we can do everywhere, and we can do it in web apps, sockets, applications using sockets, IoT applications, anywhere. Basically, our goal as a community is basically to generate the tools or generate the small layers where you can invent your own future
10:11
or you can provide new business ideas or new research ideas and produce innovation and produce new nice things of that.
10:20
Basically, we are aware that or we want you to make a successful life of programming in Fado and be also fan of it or both at the same time, and the idea is to provide a powerful language and environment where we can do innovative things.
10:41
To that, one of the things that are more to me is more produced, more proud, is the community of Fado. We are a really nice community. Fado and all the tools are used by a lot of research groups all over the world, a lot of different places, from Latin America, in North America, in Africa, in Asia, a lot in Europe,
11:09
but all over the world and it's very nice to see that. We have a lot of teachers giving classes, object-oriented introductory course, advanced reflective course,
11:21
and different usually object-oriented courses in Fado all over the world. So it's very nice. Also, these different professors and all the community have produced a lot of open source books that are available to anybody to download, to produce new content, to take it, destroy it, do whatever they want.
11:44
Also, we have a very nice tool that is an open MOOC. It's not only available for everyone, but also it's open source. You can access the video, you can access the presentations, the material, whatever you want. You can change it, you can use it in your lessons or just for fun.
12:02
One nice thing that we have, and now it's more active, usually here used to be a slide talking about the mailing list, but now the mailing list is so far away because the nice things happen in Discord. There is much nicer communication where we interact more dynamically.
12:26
And it's very, very nice. And it's a good place for beginners and also for experts and just to talk and sometimes only to hang out. Also, we have a set of different publications that we try to do almost regularly.
12:45
It's difficult because it takes time to do things nice, but we try to continue producing material all the time. Basically, we are not alone in the world. Basically, all this is part of a big community.
13:02
We have a lot of companies and universities and research institutes that they are using. Some to produce pure research, some to produce applicative research, but also a lot of companies that they use it further because it's good for their productivity.
13:22
We have a lot of many success stories, but it will take a lot of time. From commercial applications to research applications, applications for mobile, for applications on IoT or simple web or complex web applications, as you want to see.
13:43
The most important thing for me is that Faro is open, it's available, you can use it, you can hack it, you can break it, you can do whatever you want. Basically, to me it's very addictive, but maybe you like it or not.
14:01
We have all our source code in GitHub. You can check all the things that we have there. It's always bootstrapped from the code. We have an ICI process that is trying to build all the time Faro from scratch and see when we break it. This is all my presentation. I hope you like it.
14:26
I'm open to questions. If not, you can pass through our stand in the K building and we can talk longer and longer and take office. Orbeez. When you say, okay, if I have integers, then every integer is itself an object,
14:57
and if I do addition, then I send a message to that object with the other object that you add to it as an information to message.
15:05
But at some point under the hood, you really do want to add those two numbers on your actual computer. Well, actually, yes. The question was how it solved the problem. For example, when adding two different integers, at the end someone has to execute it in the machine and produce the sum.
15:23
Basically, what we have is as many other languages using virtual machines, we have at the end a layer of primitives. We tried that this layer of primitive is the smallest as possible. For example, adding two integers or adding two floats, we were required to have a primitive.
15:40
The same when we want to send a message, for example. We tried to reduce it, and even in some of the cases, when we have primitives, you can check the code and you see the fallback code. Because, for example, for adding two integers, it can be done only in FARO. Many orders of magnitude is lower than doing directly, but it can be done.
16:04
So you can see in the primitive execution, the small talk code that can be replaced in that. The idea is also that, with the time starting to see, okay, this primitive, we want to show at least how it could be done in small talk,
16:21
or which is the equivalent in the small talk code that should work.