 Thanks. So this time I would like to present a second tool. That is the name is coming That also we have developed with Martin Moprodus. That is for mining instances of code changes, okay So what is coming? Coming came from coming mining. So It's not two main users. The third one is to compute fine-grained changes between two consecutive revisions And the second goal is to mine instances of code change For instance, I Want to get all the commits that introduce an if and or a return Okay Each commit will be an instance or we have an instance of this change pattern and also I will One thing that coming also provides is to compute the frequencies of code changes, okay For instance it return the number of commits that add for instance are return new Okay, this is a goal. So why we create a coming So with two goals, the first one really was to study software evolution And the second one was to support our research about automatic software repair that I Present during the morning. So to study the software evolution. We wanted to know how an application evolve During the lifetime. It's a life cycle in particular. We wanted to know how developers Prepare bugs for instance the probability of changes Which are the committed introduced by fixes with which probability are two for instance Doing some kind of changes, it's there and the second one So the the state of the art about this software evolution studies of revolution was When we started doing coming there were one Tool that it was ever I said there was basically was a database that Store all the changes from A git repository it was a relational database and all the changes Were compute with an algorithm and also was the tool that the name is change the sealer But the problem that we found in that time was that the code change that change the sealer provides was to course brain level for instance one of the output of Change the sealer was update of method invocation Imagine that you have this change and Chains it here say okay here. You have an update of the method invocation that is right, but actually the change was It changed the argument the parameter So it took off screen. So actually we wanted to say okay here. We have An update of the first argument in the method invocation that this is fine and rain change So the second part of our research was to supporting our research about Automatics of repair so We need bugs and we need bugs for repairing for testing our Tools as after that one that I present before so to operate Automatics of repair tools. We need buggy revisions to apply our repair approaches and The patcher version, okay? Why we need the partial version because we need to know which is the patch that developer have written To repair the bug, okay, and then with this patch version. We can compare our results That what that means our patches that were automatically Generated with those one that the developer have created so the goal is We wanted to mine Baggy revision and partial revisions with our tool coming for instance at that time we present an Automatically repair system that the name is no poll the idea of no poll is was to Repair if conditions imagine that you have a bug in one condition inside the if And also to add missing preconditions, okay These were are the deep that are able or the kind of patches that no poll system are able to repair to generate so when we wanted to evaluate no poll we Wanted to mine We are programs we are come real instances of programs that has this kind of bugs So we use money to Finding commit that introduce a change inside and if conditions or to add an if per condition We also wanted that the commit Was the commit message, sorry Include some keywords for instance a link to a report and also wanted to get those commits that Introduce obviously the the if condition change that mean the patch or the precondition That change the the message and also that Introduce a change in the test cases why this because we wanted to To know whether the test cases were updated according when the patch is introduced So how coming works So the inputs are to One can be The git repository that we want to mine to mine Okay to to analyze and optionally we have another format There is that to include one folder with pairs of files Okay For instance one of the pair one of the file of the pair is the buggy version and the other is the patch That means that you want you don't have the information to analyze in a git repository repository you can Come in it's able to analyze patch pairs of of files in this talk I will suppose that We analyze git commits So this is the workflow for each commit First we Apply some filters According for instance to the number of file modifier the number of hanks that each file introduce The size of the hanks in number of line of codes the presence of keywords in the commits Etc. So we apply the filters And then we decide whether we accept the commit or not If we accept the commits then we analyze each file that was modifier By the commit. Okay, we call it file commit And then for each file we generate the AST representation of The modifier file that we call F and the previous version. Okay So given a file we compute the ST And here we know that There are different way to create this AST that means that each node can correspond to different granularities for instance the algorithm that I mentioned before change the stealer use AST that the nodes are very coarse level that means that For instance the invocation they have all information about the method invocation Inside one node. Okay and another Representation of AST for instance eclipse Shady T was to find real fine to find grain level There were a lot of nodes with not much information So we decide to work at the level of the meta model of spoon Spoon is a tool with a library for analyze transform write code in Java This is a meta model so we want you to create AST with that level of granularity does that mean that given a file we use the spoon to create an AST where each node is an element from the spoon meta model So once that so the difference is that The spoon granularity is much finer that the change the stealer, but Is a bit more course lever than the Shady T that allows us to have more compact AST So one that we have the two AST one for the previous version of the file modifier by the commit and the file from the commit We compute the differences between these two AST so for computing the The differences so we we have the two AST and we apply an algorithm that compare the two AST and marks the change that The nodes that have have been changed remove updates or move We use the algorithm that we have developed that is the name is country Gam three has two inputs Sorry as input two three, okay, and the output is a list of operations And each operation is associated to one node. Okay, the operation available are insert remove update and move Okay, once that we have the result given by change the stealer that mean the differences between the two AST We want to know whether these changes has an instance of a code pattern. Okay, so Incoming we have defined the concept of change pattern that change pattern define a set of changes between two files So a change pattern has One or more pattern action that means that a pattern action describe one particular change for instance one insert one remove okay, and One pattern action has the type of actions that are those that came from Country insert move remove updates a Pattern entity that is the description of the code element that is affected by the change this pattern entity has Three properties one is the type for instance the type of the element is a return and if and why an expression A parameter etc the value. Okay, for instance a parameter that the name is My parameter or my method called etc return new and the parent that is a reference to another Parent entity. Okay, for instance here with with this parent. We can say okay. I want to Detect all the changes or the method invocations that are inside any condition Okay, here we say that the parent allow to express The entity that is affect and the parent So coming provides an option to create this change pattern that is using XML Here we have a small example of this XML here, I want I want to detect using this pattern all the changes all the commits that introduce one if And inside the if one return Okay So the first part of The XML represent has one tag. There is entity that Represent to the return and the idea of these entities the ID one Then we represent another entity that is ID to there is the if Then we represent the parent. We say that the return Has a parent that is the if and we here will relate with the ID And then we say, okay I want that one action that is one insert that affects to the entity in ID one That is the return and another insert that affects to the ID To that is the return So this way is how we represent a change pattern So once that we have a change pattern Specification in XML and we have the change between two ST produced by Gumtree. We will match both to get the instances So imagine that we have the previous Change specification Imagine that we have this diff. Okay that it has an if precondition so the ST changes of these snippets are insert an if in a metombody and let's imagine that and a move operation of the Of the call here because we change the parent of the method invocation call So change the Gumtree say, okay, there is a move of this method invocation here Combin is able to match the first action. That means the insert of the if but We are not able to detect the move. Okay, because here the pattern say, okay, I need An insert of a return. So here is the case that there is not the matching However, you have another sneaker for instance here and add if and Inside our other return here. We are able to get from these ST changes that means one ST changes is the if method and Insert a return inside the if We will have we are able to match these instances So that means that coming will present this sneaker this change as an instance of this pattern. Okay Here I present some examples of Other specifications for instance here we use the value that means that the we want To match a note which value is return rule for instance Or we can we can match the value of one variable one method invocation, etc Here another example with more than two entities. We want to to match three entities that change Okay and the output is Shades on file with Derivation that has an instance the name of the pattern are more information for instance. Where is the instance? inside the The commit okay, how to use coming so We have the location in this case the location of the git project, okay Then we specify the mode the execution mode here my instances there's an argument for Mining a single change pattern for instance we can use the the argument action to say okay, I want insert and the Action and arguments entity type to say okay the name of the Entity type that we want to to match for instance if method invocation return, etc And here the output where coming will Write the output Another use for instance here. I have an example. We say okay Give me all the commits that in that has an update of a literal We don't care about which is a literal that we want to change. We only specify the type And here we can also specify some filters for instance the number of hanks The max number of provision that we want the size of the hanks the num the max number of Files per commit, etc. There are we have a lot of filters that are Documented in in our git space And finally another example that we can specify specify the File of the pattern of the the file that contains the pattern that we want to Mine for instance the pattern that we have seen before okay, so the second option is to Is the mode if that produce a so put all There so It computes a shade zone that compute the Frequency of the changes. Okay. For instance. It's a okay here. You have binary operator operator that we found six Changes that affect to binary operators. We have found two changes that affect invocation, etc Come and produce this information at different level of granularities for instance here. It's a okay we found two instance of invocation insert of invocations inside the block we find two instance of Update of a binary operator inside it etc So they show the the information at the different level of granularities So coming also provide extension points to Extend the the behavior In particular we can specify the input right now we have two kind of inputs git repository or File systems that means pairs of files We can add new revision filters With the filter or we have right now are related with the commit message the site of the commit, etc We can add new analyzers for instance another AST Algorithm but a new granular a new AST with different variety a new technique for pattern detections and We can also add New outputs processor right now the output is Present in the standard output or in shapes on the files, but we can Generate another kind of output for the evaluation so we have Analyze difference commits from the data set developer shape And we evaluate whether coming was able to detect Different instances of change pattern related with if so Most of them were Detected we have two cases of false negatives that actually was related with the output of the AST deep algorithm sometimes that happened that the deep Produced by gum tree was too complex With a lot of changes and the changes were not as we expect So that's why we are not able to detect the pattern even such output from gum tree So to sum up we found 26 out of 28 Pattern instances that all were true positives and actually for some cases Come it was able to find more than one instance of the same pattern inside the same file So future work we are working right now in adding new New different inputs on filters Improving the specification that right now is quite simple But we want to know more features inside and improving the the output It's available on github so if you want to To use it so that we have there the instruction how to extend it some examples also so conclusions coming is a tool for analyzing fine-grained changes between Two revisions So it allows to mine instances of code changes that were specified in XML languages It exports the result in JSON formats The code is pulixy available, so we welcome pubrokesk comments, etc Okay, that's all thanks a lot so His question was if we mine the source code or the bytecode So we mine the source code so we take a version from And from a commit We take the source code and then we mine the changes between the version of the commit and the previous one But the code source Okay, he wasn't was whether If we use some machine learning technique for generating the part the pattern is a nice question We haven't do that for because for the moment. We only wanted to get instances for particular Patterns for instance the patterns that I show add an if And I need precondition or add an if return because we needed for evaluation of repair approaches But we we can plug the idea is to plug machine learning techniques to get these patterns Automatically apply to another language is No, so I know all the Yes, so his question was if There is some research related with similar research related with another languages From my knowledge, I I don't know when you tool that detect instances of change pattern for another languages but actually it With coming it could be easily done, but changing the AST Generator so that means the parser you can parse Another file in another language and instead of generating so We generate the same AST But using another parser and then it is it will be the same So the the matching parts will be the same. So it will be similar Thanks