00:00 Welcome
01:23 A tooled approach to programming and execution of skill-based robotic behaviors, Matteo Morelli, CEA List
39:35 Discussion about Behavior Tree REP proposal https://github.com/ros-wg-delib/rep/blob/master/rep-2018.rst
—
Please see https://docs.google.com/document/d/13TCHp3ycbDa2agGs0SjP3CpTllUeguAcXqih5LlCVDg for the protocol and agenda. Please join https://groups.google.com/g/ros-wg-deliberation/ if you want to participate in the working group.
Welcome everyone to the working group meeting um today we have basically two points on the agenda um let me quickly share my agenda before uh we start so the first um point would be a presentation by mattio um Mato is also with us in the C
Project which was kind of the main point where we decided to start the working group um and he will talk a bit about his previous work on how to execute a skill-based um robotic behaviors um I guess mattio would it be okay if you speak for roughly 20 minutes
And then we take five minutes for questions okay then we have another half an hour to discuss this um rep proposal that I made I’ve seen theid thank you very much for the for request already but I guess we there also some points that we can discuss
Live um while we are here um but for now I guess um please Mato the stage is yours uh so hello everyone uh I’m M Morelli from from CA I’m research engineer from from CA in France uh so today I will talk you about the work we are currently doing at CA so
Mainely a to approach to programming and execution of SK based robotic behaviors uh so there are two main parts in this uh talk yeah sorry you see the screen right okay so I before starting going to this L I wanted just to say that there are
Two main parts in this talk so the first is the software architecture that we are developing for executing skill-based robotic behaviors uh which is called squidly it’s a name that we find interesting because reminds the intelligence of this uh animal thep which is uh very much appropriated for for deliberation and
Intelligent behaviors and then the two approach that comes with uh an approach mostly based on low code programming and then I will um give you some uh perspective on the ongoing work that we are doing and telling also something about future work so let’s start uh with uh okay the software architecture uh
That I’ve just mentioned before so the main motivations for for developing this software architector for executing skip based behaviors um you see a video here uh we have uh done this atca this is a challenge that we that we did uh basically it was I skip this part at
Least for the moment it was a system set up with a vision system a robot arm and some gear units that comes from a nist challenge and the robot basically has to do the T that you are seeing right now so pick every part of the gear assembly
From the assembly tray and putting it to the to the deposit trade so uh to to to construct the full the full gear so here we have uh a lot of skill in the system that must be integrated we uh we have we had four teams at CA very much expert in
Their field of expert so computer vision robot control uh digital twin for motion planning uh so what was needed was an architector capable of orchestrating all these skills and there was also a part related to human machine interface uh so that uh when something went went wrong uh so like for
Example um a part in the in deposit trade that is not found like here uh for example we are asking the robot to perform uh to to um to grasp a kind of of gear that is not available uh then we needed to to interact with the human
Machine interface and also a a motion capture device that was able to recognize the operational zone of the operator to suggest the robot the next option to do so given that in the previous case um the so given that in the previous case the operator uh did the the work uh close to
The deposit tray so the system was suggesting to the Rob to restart doing the task again so the robot is going to select the the gear and continue the assembly and here the other way was that the human operator could do the task by by itself uh and so the system
Was able to to infer that the next good move for the robot was uh continuing the with with the next with the next operation because the the other one was already been done by by the so all this to say that we need uh the integration
Of a lot of uh skill capabilities from complex system but even more complex than this because we had um projects where the use case involved multi robot setup this is the use case that we are doing right now in convince there is a robot arm and there is a
Mobile platform and the mobile robot has to fetch uh blocks and put them in a kill card so I don’t go to into the detail here but just to understand the complexity of of the system there is a a vision system again so we we did the previous uh experience the previous use
Case with in a dual arm setup uh so the the need of orchestrating two arms was was quite demanding and we also have uh used um this architecture for not only for I mean robot in the traditional sense like arm and mobile platform but also agents like drones for example that uh have
Used uh in our case was Behavior tree based uh reactive navigation strategies to to avoid essentially obstacles uh for when doing some navigation and then Landing to a Rover but we also have used them to to coordinate uh agents in simulation scenarios like in autonomous driving
Where we wanted to uh to verify for example scenarios where the car has to avoid The Pedestrian and we wanted to uh coordinate the mo the movement of the different agents um in such a way that we could be able to reproduce a dangerous situation so exactly to see if
The driving policy of the car was able to to work well and so on so all this uh is our motivation so uh essentially we we deal with complex systems uh of different sides and different number of Agents with different components and so on uh we found this uh skill abstraction
As the capabilities system can the system components can expose as a as a good way to to orchestrate the different agents in in the system and uh we wanted to develop an architecture uh a around time architecture that could be scalable and could be um capable of integrating all
This all these different components uh so of course based on Ross because uh it’s the the standard technology that we use uh in in our projects so uh essentially we our architecture is component oriented of course and we we have as I said before uh components that provides the the real
Algorithms um like computer vision robot control but also reinforcement learning possibly or uh uh we have digital twin that can um essentially represent the the geometrical data of the scene and all the information that we have that we have in the scene at at the geometrical level and then all these components have
A life cycle and uh they can expose uh what we call for example Atomic skill so the atomic skill is the symb capability that is immediately related to the algorithm so uh the atomic skill uh in this case for example find object is implemented by a computer vision algorithm but for example follow
Trajectory is another example of atomic skill that can be implemented by two entities the all control and the digital twin in simulation and they uh use in our architector the same API so that we can map uh it easily to to the different components then we have a bunch of other
Possible Atomic skills and these Atomic skills can be composed to to to essentially uh Implement comp what we call composite skills for uh implementing more complex functionality more complex in the sense that is a functionality with a logic logic that can be a sequencing of a set of skills and
Um or or other strategies uh with with different complexity and then of course all of this can be uh compose again to to provide uh even more complex functionality more and more complex functionality uh until we uh essentially Define a task uh based on all the skills that is
Executed by a task a task plan sequencer so what I didn’t mention here is that the blue cylinders here are part of a a shed knowledge base that we foresee in our architecture uh the knowledge base has um at the lowest level the geometrical information uh that comes from the the
The digital TN that is the The Entity uh that is um uh feeded with with the data from the perception system and can provides the object poses the robot configuration and so on but then we have also other kinds of of knowledge like the static parameters for configuring um the the parameterization
Of the skills and uh the um the task the Rob what must must execute so if we go in a little bit more close view of what the atomic skill is uh we have uh so some naming convention in our architecture for for the skills in terms
Of device the main and and the skill name uh these are implemented using the action pattern in in Ross The Binding that you see here in the API can be C++ python calls or just a binding to another medware so uh essentially uh what our Atomic skills
Ever assemble is a a life cycle node so with all the operations for configuration uh Etc uh that can expose primitive skills as as action servers but also uh other data computation Port as services for example to evaluate conditions Etc but also Publishers subscribers for for data sharing when
Different components have to to interact among them to realize a complex functionality uh or to to Signal some some error or or things like that uh for what concern the um the composite skill uh on the other hand we uh we have the the behavior executor obstruction essentially the a composite
Skill as I said before can be implemented uh with a composition of atomic but also other composite skills uh and we U implemented the architecture in such a way that uh can be the behavior executor can follow generic um Behavior specification like like for example beibit trees or even fin State
Machines uh so we have um some uh class hierarchy that is a little bit schematized here so essentially a behavior executor is is a life cycle node in Ross and the user has to implement just a couple of function to uh basically being able to instantiate to instantiate a behavior executor so
Get name which is um essentially um a method to um indicate the name of the action uh that the name of the skills that that the behavior executor is going to implement uh and also other function and also the bind policy parameters because uh there is a need to to to bind
Essentially the goal uh that the skill is going to receive uh with the internal execution context of of the skill itself to uh essentially execute um the to to remap the argument for for reuse uh in the in the skill Logics so for example liting Behavior we have both remaping
Remappings uh and and Blackboard items so from a point of view of the implementation uh we have um the executor context which is an Abra class uh which for now is um specialized by the behavior tree execution context and in the future we we are starting now to
To deal with also supporting fin State machines so the the most of the effort for now was essentially in implementing this architecture to support Behavior three uh based Behavior Uh execution so uh essentially uh um a composite skill uh to summarize is is a behavior executor uh a behavior executor that has
A complete instance of an execution context in in our case as I say for now we all Implement Behavior three compatible execution context so this context uh means a data structure that embeds for example an execution engine uh then um other specific um functionalities like a contextual representation of the information for
Example in the behavior 3 there is the Blackboard um and then some generic methods uh to uh to be able to to run the the logic so for example to to be able to run uh the the process of the of the whole logic in in the in the behavioral specific
Uh so yeah so we provide some uh of course another part of the of the the executor is the option server which is capable of uh reacting to um execution requests so essentially uh the behavior executor is exposing a composite skill for example a a move to skill uh so when it
Receives it needs to have an action server of course to to be able to react to uh to request to to execute the uh the composite skill uh then we provide some implementation of this in terms of Tas plan executor uh but also other example uh instantiation but I I don’t
Want to go into much detail here right now uh so for what concern the implementation this is a point that I I I find I think could be interesting for this working group so we didn’t reinvent the will to to reimplement all of this we start with the great work done in navigation
2 navigation 2 uh provides for our BT executor context that I just described right now a lot of code that is is that is needed so we we we get we got inspired very much from this we just uh tried to extract what was the um navigation to agnostic parts for
Executing Behavior tree to have a framework that could execute Behavior trees in general so without being too much bound to navig to concept Etc so for example the behavior 3 engine class it was great because was a wrapper uh wrapping nicely Behavior 3 CPP uh the its Machinery so the factory the XML
Parsing the the nodes with the plugins Etc and it only depends on RCL CPP so it’s perfectly reusable in any other context and not only navigation too so with robot arms it’s perfect with drones is perfect ex then there is the BT action server class still in the package navigation to
Beav 3 which uh gave us an excellent inspiration for the the structure of the context so the way in which the behavior 3 engine is embedded uh the um and and many other things so what we did differently was uh the way which uh the parameter some
Parameters are passed to the node so in navigation 2 uh they adopt um I mean uh an approach uh which exchanges Ross node through through blackboards which is their way to to to be able to uh to make all the Machinery work for for um composite skills but uh
Uh also following the advice in some discussion by David we we follow a different strategy and we we use the additional arguments pattern of behavior 3 CP uh and then another Point another difference is that we avoid explicit ports to remap um weav three option um directly at run time we only allows
This remapping in in some system configuration phases and uh another difference is uh that we use a push and P semantic to know which behavioral specification must be executed so this is a schema that I can use uh I can describe shortly to uh to explain uh essentially to to
Um to make the link with what I was saying before about composite skills so we have the Tas plan sequencer at the highest at the highest level which is in charge of getting a task uh description in form of a behavior tree a complex task uh which
Is any complex task that you that you want to execute and let’s suppose that at a certain point in this complex task there is is a move to skill that must be executed okay so and this move to skill uh involves uh a specific robot because
In your setup you have two robots a franka arm and a UR 10 arm that both expose the follow PA skill uh that allows the robot AR to follow a path previously computed by a digital twin so we know which robot as to execute um the task and we know also
Which uh object we want to move to so the point is that uh so first what I was saying about pull and push semantics to know which behavior specification has to be executed uh in the in the move to composite skill the way in which this is implemented in
Na two with the navigate to post for example the behavior tree is is passed as an argument in the option uh in the option goal uh what we found more interesting was to enable this pull on push semantics uh to let the composite skill to interact with the knowledge base
Which we suppose it knows at any instant what what is the most appropriate policy uh that implements the move to that must be executed because why I say that the knowledge base knows at any instant which is the most appropriate policy to to be applied to realize a
Move to because maybe we imagine that there are additional modules in this architecture and these modules are about situation awareness so situation awareness are modules that uh based on the current state of the environment and some inference capability can determine for example what is the most appropriate
Policy for doing a a move to in a particular context so a simple one without recovery for example in case your robot is just moving in an empty room and there is no much obstacles and so we we do not expect to be uh to to to have
To do some recovery very often or things like that but it can be of course different if the environment where the robot is moving is more dynamic or with a lot of obstacles so depending on the changes of the environment and the inference that some situational awareness comp can do we can imagine
That it’s going to populate the knowledge base that can be accessed at run time from the uh composite skill to know which policy has to be executed so this can be done with a PO semantics like the one implemented here so the the move to skill Reed the uh the gold
Request and it goes to in the in the goal handle it’s go it goes It goes to um to query the knowledge base to to know which policy must be executed and then continue with the with the execution for example here we have a compute part which is only bound to a
Digital twin so okay no problem but there is also follow PA which uh that yes we are running a little bit out of time how much how many more slides do you have uh okay so I can speed up a little bit with the with this part and yeah
Okay I I how many minutes uh do I have yeah H minus five okay okay no worry I can do it uh so um yeah so we use the uh the robot identifier to uh to decide to to identify which uh remapping has to be done at run
Time uh but this is a remapping that was configured uh in the configuration phase uh before um so in this case uh as I said we have the the PO semantics but we can imagine also that the um situational awareness component as uh communicated to the sent to the uh
Ros mode of the composite skill uh which is the policy and in this case we we we call that a push semantic so that there is no more need of this interaction with the knowledge base for the composite skill so this was a little bit about the
Timing don’t go into the detail but just to say that for example the go request move to in the handle goal phase was connecting to the knowledge base interface and get back the um the policy to be executed this is a pement is is a p semantic otherwise this part is keep if
Uh the the situational awareness component as sent already uh to the composite skill the the policy to be to be executed okay so uh that’s all for the for the architecture uh What uh we did was indeed um implementing this architector and using it in uh scenarios like assembly here we see in
Simulation um a task with the uh with a roboton challenge with with with a setup from The roboton Challenge and we use flexible deployment uh for and the rapid and effective management of software dependency thanks to the docker visualization technology so we deploy all this infrastructure
With the uh with Docker and then we program uh this also with the for robotics that that is our L code um programming environment for for this skills so even that I’m a bit out out of time I avoid to give a short demonstration of the
Tool uh but here is just to mention the main features so uh the tool implements the robes methodology uh robis was the project where also PT CPP has been developed and essentially pushed for the adoption of model driven approach in in the development of software for robotics so
The basic features are modular role based design so we we have views different views for different roles uh to enable stakeholders in the robotics value value chain to exchange model artifacts from which code generation can be can be done but also some kind of analysis we offer some preliminary uh capabilities of
Functional analysis uh for example and uh yeah there are some links here with some videos to see the platform in action so go fast here and what about our ongoing work we are integrating in our architecture the part related to uh T planning uh to to bring in deliberation
Capabilities so again from planning domains and specification of the planning problems Reas planning integrated that can provides plan uh that is translating into a behavior tree that again is executed by the architecture that I described before and then we are working very much on this part which is called anchoring and it
Closes the gap between uh the geometrical information in the digital twin provided by captors sensors like vision and so on and the construction of symbolic predicates that can be used by gas planner to plan I think that’s all there is this video to show you uh our our preliminary result of
Integrating plis to in our architecture uh with a preliminary anchoring capability so we are working to make it more robust uh more scalable and implemented on top of onology so just to tell that the gold State uh was different here from of course the the initial State and the
Robot has to arrange the cube in a certain way to to free one position then you see here the automated trans translation um to uh to a Beav tree from a t plan and the robot afterwards moves the cube to achieve the goal so that’s all on my side this was
The last slide uh I didn’t have the time unfortunately to to give a short demonstration of the tool maybe another time the loow code tool that we develop maybe another for another time if it’s pertinent uh but the main message that I wanted to share with you in with this to is that
Um I think many of the participants to this uh working group uh have needs like the one I described at the beginning so moving generic robots agents uh in in a skill-based uh approach and it would be great if we could have a common architecture uh not embedded in a framework like for
Example navigation 2 which is what they developed is great but what I wanted to to to stress out here is that uh many things are really generic and could be took out of navigation tool to create a framework that could be uh reused in other context without too much
Dependencies and with also some improvement from an architectural point of view uh as I said before uh using the appropriate patterns from the C++ for sharing parameters and so on the usage of this distributed knowledge base and so on so that’s all on my side I if you
Have question I would be happy to to answer thank you very much Mato um I think we have time for one short question but then we also have some other things to discuss before Five maybe um is there I mean you mentioned on a slide that there’s the need for a separate runtime for Behavior trees right is this part of squidly or is what is quitly yeah well um I mean yes the run time for the moment is part of the of
The full architecture that we call squidly and this architect I I didn’t describe the in In its globality I mean there are other components that I even describe like situation awareness component and so on I mostly Focus for this talk on what I I thought it was interesting for this working group uh essentially the part of behavior execution for now we implemented it based on Behavior trees
Using behav 36p it could be done also using State machines like smack this is something that we are going to test very soon uh composite skill can be a composition of the different formalism so um we are open to bring this part uh out of our architecture because this is
Uh indeed very much inspired from the working n to and this this is a basic uh in our opinion uh element a basic asset very very much needed that could help uh the adoption of even more a of behavior trees or other kind of behavior specification in an easier way if we
Um don’t put this in a single framework and then we have to all the time to clean up this so the point is that when we started uh with the with the motiv with the project that I described in in the motivation sections we found that what was in navigation 2 was
Closely what we needed but was not the completely the right way to to do it we we had some different ideas so we wanted to uh isolate that part to be able to build uh around it all the components that we needed and we think that this experience
Could be shared and if there is enough interest we can end up in in a in a shared effort inside this working group to to bring this development uh uh in open source and in an agreed way because I think that many other partners have this some somehow because I think mve it
For example mve it pro is capable of executing behav uh if we look at other Frameworks like Isaac cortex for example so I think that at a certain point uh if would be nice to have a common agreed solution from which everyone can start maybe I don’t know so
This was something that I also wanted to to bring to the discussion yes yeah thank you very much I think this is a very valid uh idea and one step that uh we took towards the direction or what I had in mind towards the direction would be that we as a working group
First maybe understand what we mean if we say Behavior trees and uh therefore I created this um rep I’m not to I’m not 100% sure if rep is even the right format but let’s try this for now um so for those of you that
Had not have not had a chance to look at it I guess I could uh I briefly show the document and um if there are other and then we have also like uh the video also open the proquest already thank you very much for that um and then I guess if
There are further questions please feel free to reach out this is under of this um GitHub organization Ross uh working group deliberation and that’s just a fork of the rep uh of the Ross rep repository basically it goes into the first a bit of an overview of behavior
Trees um one thing that’s maybe maybe also new is this hold signal that we have to specify um I I could think that maybe we need to do some more to specify this further but then for example here under execution notes you will find that what hold signal does that’s something
That’s usually not found in the literature but as you can see from um g. CPP this is necessary when you up with robots um then basically the one of the core things is this table we actually compare what how Behavior how these controllers are called in the in this book by um
M um how they are called in the library and how we then propose to use the name which basically means that we kind of there’s no sequence node per se but there’s basically a reactive sequence and sequence of memory node that we co differentiate against so that we are always sure what we
Mean and then now there these controlls are explained in a graphical syntax and then with a pseudo code that um details the actual internal workings of these control noes I I would personally still prefer if we had some kind of code here that is actually executable but I thought that we could actually
Like test given implementations of behavior Tre against this Behavior but I’m I’m I’m still I still don’t have like a real good practical idea how to achieve this so for now we stick with this pseudo code where we then kind of we would have to manually match this
With a given implementation to see if it’s doing uh what what what that here David uh you raise the hand you want to say correct so first of all thanks a lot for putting the work to write this so it’s kind kind of convenient for me to jump in when you do
The most of the work so thanks thanks a lot so um first first a very pragmatic suggestion uh if you could enable in the GitHub repo the discussion I think it would be a easiest place to to you know exchange opinions because because there’s no other we don’t have issues we
Only have po request activated so so that that’s a tiny suggestion to make future communication a little bit easier um so then about so since we don’t have at that I created this PR where basically I point out most mostly to have a place where we can start exchanging opinions so
My my problem is in the way here the sequence with memory they they say that the sequence with memory is equivalent to se quen in P Tre in the Top If you go on the top um on the comparison table yeah uh the so the second
Line uh I well yeah second line and third I strongly disagree with this statement and actually the pseudo code kind of that is used is actually not correct it doesn’t represent what bcpp does so I would like to maybe start this discussion because there is actually
There are you know what we see there the pseudo code we see there is not what V TR with does um and and uh I I’ve been looking at the um publication from mik and I insist that there’s no the discrepancy that is mentioned in in the table is not
Correct doesn’t exist so what it calls sequence with man memory is sequenc with memory in BPP um so so I that’s my point of discussion before finalizing this document so you know to correct this and as you said I completely agree with you that having real code and not pseudo
Code would be better because the devil is in the details so I think that the sudo Cod code is giving some you know doesn’t Define something for example where you have the mouse this to tick from last iteration uh that that’s ambiguous because what is that value when you
Start it the first time so there are these so since the de is in the details and we are trying to really formalize and also what you suggest that creating some kind of unit test I love that is I believe is what we should do so I completely agree with you that maybe
Real code would be would be more effective here yeah but I don’t really know a good way of I mean because to like really then verify that when we have some executable code to really compare this to a given implementation we would have to have a lot of insight into this given
Implementation as well I mean of course yeah we could make some kind of Black Box around the given behavi implementation with Ross basically but oh but I mean if it’s a unit test why should the do you need Ross at all there’s no need to do Ross I want to be
Agnostic to the language I think cannot be can be agnostic to anything else but the language so even if it’s Java or python uh I don’t care but it must be a language otherwise you cannot ex but I mean we can’t make an unit test for that langage
Agnostic uh but but uh you know when I when I mention unit test is more like giving a certain input you deterministically get a certain output right so so so if we have a table of the input for example uh given five consecutive tick you get uh you get you know this final
Result uh and and and and of course uh we don’t even need the Blackboard here this actually there’s no use the Blackboard really here in the this pseudo code so I I know it’s not it’s not trivial but I think it would be beneficial otherwise we need to triple
Check this suda code to see uh if there is any error and I believe there right now there isn’t unintentionally there are some omissions there important to fix so what would you what you be your suggest to make this executable I mean uh if we decid that is as I said
A python C++ whatever language it would be easier to create an other word example of what I have in mind um otherwise otherwise you know I don’t I wouldn’t know what to start if we do it in one language I would ideally want to to be able to check this against
An implementation in a different language where that does the same thing right yeah I mean the the usual trick to don’t you know to avoid being uh being uh you know is is is using interprocess communication that is the most neutral way to you know to make something communicate with something else when
They are written in different languages um but what is say but maybe it’s just a table you know a table like a text of inputs and then you have a text of outputs and then you know you just need a file IO really yeah yeah I will
Actually if you think about it you know these coding challenges that are you know that are sometimes used that’s what they do right they say oh you your inputs pass your input from this file txt file and then they check and then print your output on uh on the console
And then they check if the output you print is the expected value so yeah I think that file IO with inputs and outputs would be the the best way to do that and inputs here are what are the states of the children in every iteration right and outputs are what
Actions are ticked I think yeah it should be something like like this something like uh you know we have maybe some kind of test uh child to say oh you always return success or or you need to return success uh you need to fail three times and then return
Success so you have this kind of uh hard coded this sequence of return values and and that Express the what that child note will do and um yeah you’re right I mean we need we need not only detect actions we also need the return value of the whole
Of the sub tree we are considering or this control not yeah the the child are are mock are mock like mock testing and what we are testing is for example here is the controller so we have mock child that has a certain deterministic output and we are checking that given a
Certain uh I don’t know success success failure then the control return failure or whatever they if that’s sequence so as I said that the language agnostic way is is probably file IO and I I and I’m happy to you know to try to create some
Kind of H word of how this could look like um but anyway we’re we’re going a little bit too fast so I will say thanks Eno I see you there thanks thanks a lot for for you know working on this uh let’s continue the discussion on
GitHub and uh and try to at least finalize the current pseudo code there um yeah enrio do you wanna yeah so I wanted to first of all to thank you David for uh looking at the at the document and for your feedback uh that that’s very useful and indeed you are
Absolutely right that the Pudo code for um no with glamory is wrong uh there is no doubt that the two TI should be um reset before returning success for examp for in the case of the sequence uh so my understanding is that the difference between uh a SE in the terminology of
Behavior 3. CPP the difference between a sequence and a sequence with memory is what do we do uh like whe on is whether we reset the twoti we we reset the memory in case of failure correct and uh the sequence we do reset it and the sequence with memory we do
Not uh is that correct yes it’s correct okay that that’s great so um regarding the um table at the beginning uh I think it is a um matter of terminology so I understood from my my main source on mikel’s work is his book and from the description of notes with
Memory in his book I understood that uh the memory was to be reset even in case of uh failure so that’s why I compared like that that there is this comparison in a yes that that one at the beginning uh so I of course I I might
Have misunderstood it and in that case uh this has to be adjusted so uh thank you for pointing this out and yes let’s let’s keep uh the conversation going on uh on GitHub and hopefully to to uh fix the like all the all these uh issues with the document very
Much yeah then thank you very much for the um feedback everyone in case um anyone is interested we are still looking for someone who would like I can still give a presentation slot to someone for the next meeting but we could also um extend this discussion I
Guess into next meeting that be no problem and there’s also one raised hand from Calvin we can’t see you now but hi we can’t really hear you no okay no sorry okay no good but I I think we are anyways in the end towards the end of the meeting
If there’s a question towards anyone then just send us a message cvin or we can talk next time okay um yo and with discussion David you mean that there’s a separate tab up here right or you mean if yeah if you go to settings that’s pretty easy in settings
You’ll see if you scroll down here there’s discussion you just need to that’s done save and we’re done I prob don’t have to save but they are here so so this is like a form so I think that that is is the equivalent of a form that’s it see easy
Peasy so if there’s anything uh you know so so we use PR for actual PR and we use this for any hey guys uh what do you think about this blah blah do you then maybe you want to uh your P request then maybe we just um merge P request
Especially for the I you know what I’m going to change the PO request just to contain the grammatical errors this will make sense nothing else and then the discussion will be moved in discussion okay so Kevin wrote that the question was how to um contribute yeah I
Think using this discussions is a good way I mean if you have something that’s a clear for example a typo a clear correction then feel free to open my Pro request and for everything that’s worth talking about then I guess we use this discussions and then if there’s a
Discussion already on your topic feel free to contribute or otherwise open a new one yeah cool then um have a nice week everyone yeah you you too thank you thank you for the presentation bye bye by bye thank you bye bye