 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, reflected language that is quite small in itself but it's very powerful because on top of it we have created a lot of things. 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 it makes things a little more difficult. Well, I am Paolo Tessone. I am one of the engineers working in the Faro consortium. Basically, I am working also in the development of Faro with Stéphane so I want to present it. I think it will not be the same but I will do the best that I can. Well, Faro, what is Faro? 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 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 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. 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 it basically a 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 all methods are public. We don't have the idea of private methods. They are virtual so they are automatically executable from the subclasses and we can have override without caring at all. All attributes are protected for us and we are using a single inheritance and with small asterisks there that I will talk later. Faro is fully right in itself. All the code Faro is bootstrap from the sources. Even the virtual machine is mostly right in a subset of small talk, 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. 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. It's fully inspectable. We can check all the objects in the image, all the objects in the memory and we can change it them and they have a lot of reflective API to modify. Also, as you can interact with all the objects and classes and methods are also objects you can take a class and inspect it or modify it or send messages to modify it in your program and doing nice reflecting things. As I told you before we only have objects and messages. It's a real pure object oriented work and everything 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 false not, it should return true and true not should return false. We let the receiver decide. We will use it doing polymorphism. 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 and inter respective classes. 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 to modify, this is implementation. So with this not much concept, we have a very powerful language and environment that basically it does not 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 or well, we need a no type declaration as is a dynamic tip, dynamic, oh sorry, dynamically tip 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 visibility for us is not important because basically we want to give the power to the developer and if the developer want to send a message should be able. At the end is the 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. Basically what we can do on all the objects is that we can execute code directly interactively and with this see the different results and for example we can take and reimplement how every object is visualized and it's so easy of doing this that we can for example integrate with a powerful visualization framework that we have that is called ROSAL and 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 or for example if you inspect a directory there is an implemented way of presenting it as an explorer of this directory and for example if you inspect one file reference that is an image it just shows the image in the inspector. 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 will execute when we are executing or sending messages to instance of dice handle so they will have this implementation of plus. 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 to say okay I will do an extension but every time you are inspecting the AST node I will provide a 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 visualization and new tools in an easy way because as we are developers we think a lot about how to have faster development process and one thing that I really love of Faro is that it is a live programming environment you can basically develop in the debugger. This is our base debugger where you can execute code and do debugger stuff but also you can come here and modify this method 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 and you start debugging it until and you provide the smallest solution possible. A nice other thing that we have is that this debugger is basically as multiple as everything else in the system so for example one of the users of Faro has implemented using the same debugger a debugger that this is a language called Vienna if I remember well and they have implemented an interpreter in Faro but debugging the interpreter is boring and takes a lot of work so they have 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 Faro itself and tools for Faro 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 application usage sockets IoT applications and anywhere and basically our goal as a community is basically is generate the tools or generate the small layer where you can invent your own future or you can provide new business ideas or new research ideas and produce innovation and produce new nice things of that basically we are aware that or we want you to make a successful life of programming in Faro and be also fun 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 to that one of the things that are more to me is more produce more proud is the community of Faro we are a really nice community Faro and all the tools are used by a lot of research groups all over the world a lot of different places from Latin America, North America and Africa and Asia a lot in Europe 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 and different usually Object Oriented courses in Faro all over the world so it's very nice also these different professors and all the community has 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 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 videos 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 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 the nice things happens in Discord there is much more nicer communication where we interact more dynamically and it's 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 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 we have a lot of companies and universities and research institutes that they are using faro some to produce pure research some to produce applicative research but also a lot of companies that they use it faro because it's good for their productivity we have a lot of many success stories but it will take a lot of time and from commercial applications or to research applications applications for mobile for applications on IoT or simple web or complex web applications as you want to see the most important thing for me is that faro it's 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 we have all our source code in GitHub you can check all the things that we have there it's always from the code and we have an ICI process that is trying to build all the time faro from scratch and see when we break it so this is all my presentation I hope you like it I'm open to questions and if not you can pass through our stand in the K building and we can talk longer and take office for instance when you say ok if I have integers then every integer is itself an object and if I do addition then I send a message to that object with the other object that you add with the information to the message but at some point under the hood you really do want to add those two numbers so you're actually together 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 basically what we have is as many other languages using virtual machine we have at the end a layer of primitives we try that this layer of primitives is as small as possible but for example adding two integers or adding two floats we will require to have a primitive message for example we try 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 all in faro it's many orders of magnitude slower than doing directly but it can be done so you can see in the primitive execution the code the small talk code that can be replaced in that and 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 or which is the equivalent of small talk code that should work