 Helo? Helo? Stalki? Stalki? Helo? Helo? Right, so it's been pointed out that I am now the one standing between all of you at your dinner. So when the last person slurred sounds at all, I'm going to join you. So quick audience survey again. Who has ever performed a bisection binary or otherwise in the audience? Okay, one or two. So I'm just going to start with a quick introduction to what it means to perform a bisection. And if it was anyone, I'm sorry. If you know something, excellent. And I hope this will also be of use to any future QA members who might watch this on YouTube, if I'm very lucky. So, something to pick introduction, followed by how to do technically, followed by questions, which will not happen because we'll all be down with having something. So, bisection is a way to find bugs. It uses the git repository. And it's a way of finding a bug in what, in the very last number of commits, without having to test the loophole individually. And this is important for reasons which we'll come to later. And Jordan Wettelsen, who is not present, originally invented the system of binary bisection, by which we saved the trouble of compiling the 100 versions of the rock. Is yourself more actively provided with a repository, which you can use by this problem. So, to start with, how to understand a little about how our git repository works. There is a mainstream of commits on the master branch. And at certain points, roughly in six months, hopefully, exactly in six months, we branch off and release from that branch, there are sub-branches, which become, like, a line or something, and so forth. When we look for a bug, we usually have to look for this part in the master. Now, the reason why we very much want to have to test every version of the bug, is because we've got 10,000 people in each six months. It goes up, it goes down. Here, I've counted the ones that are on the master branch. In fact, sometimes we've merged a few other little branches. So, just to make sure, in fact, we've still got 10,000. If you count the merged branch, you find that we are just over 10,000 branches. So, how does it work? What we do is binary search. So, when we start by knowing where a bug doesn't occur and where it does, that's what we have to know to begin with. We have to find some point in time before it happens and sometime after. And between those, we take the middle, and we test that one. And based on that, we can throw out half possibilities each time. And it turns out when you do that, you can get 10,000 in just a few tests. Eventually, we've gone left, gone right, gone left again. Anyone who's done, I said, may know that it often tells you, but it always tells you there are, frankly, a certain number of steps left. If you look at this, you'll obviously see why. Because when you get down to a few, anyone choice you make, you'll see it's a bad mix, then we're done. If it's a good mix, then we'll just do one more test. So, it doesn't know ahead of time how many tests have to run. Why? Finally, we get to the end, you know, where we're produced. So, the system that your mark was okay marked with was to see how to compile all these commits yourself to test them. We pre-compile a selection and commit them to a gigapository. It takes some space, but you only have to down once or any number of bugs in the range of covers. And when you have all these final reads ready, you can test above and find out the region in which it's introduced in a matter of minutes rather than hours, which is a great improvement. So, leaving would have a lot of bugs, and it would all help you to get it. So, the original kind of gigapository back in the era when computing power was just a little less than it is now, was sparse. And that means that for every certain number, if we end the source of bits, we only killed one binary. So, every 32 or 64 source of bits, we would have one binary even if those edges wasn't treated. It's a lot better than I think, but doesn't quite necessarily get you to finding out where exactly a bug was introduced. If you're lucky you can figure it out, if you're unlucky you still have to compile the source in that region. Most of those are now obsolete. We have a few that cover regions which aren't covered by any other depository. That's something I've been working on recently. So, the amount of time that is necessary to use a sparse depository is a lot less than it used to be now. So, on to the background. So, for sparse we've set a test, and whilst there was a lot of bits, but we only had a few. Well, recently I started building a fine grain of the trees where there is a binary for every possible commit that can be built, which makes it even a lot faster. No more source compiles the input that is necessary, provided that it could be built in the first place. We've been getting better at that recently. There's still a few sets of commits which don't build if you're a developer, please make sure they do it. It helps a lot in the devotee. So, now, because of what every source commit we have, we've set commit quite great, because it takes off to one of the work builds that we've set for that time. Quick note, some of the older depositories, some of the newer depositories for older periods of time, I've recently built ones for the 4.1, 4.2 and 4.3 regions of history, but I've built those incrementally. That means without making a clean build for each one, simply pulling and rebuilding each commit. Now, the build system, the further back you go in time, the less reliable it is. There may be bugs there. If you find yourself using these depositories at a pinch of salt, may be necessary to check that it makes sense, but it's still a significant improvement on not having them. We've managed to, there are quite a lot of very old bugs using these. The main depositories we now have, there are more than these, but these are the relevant ones. The coverage starts by reaching about a year after the Labour Office. More than that, we have a good chance of finding where a regression was introduced quite quickly. Anything older than that is actually a lot more obvious from there than you can imagine. Even before the Labour Office, there was obviously actually an office and both back in time and back eventually there was a staff writer and each of these had issues, but some of which are still with us. At the top here are the two depositories that are useful, which are sparsial depositories. The fourth, we all would probably agree because it goes back in time to the others and the daily debunking tool was three because we don't have any depositories yet, which others the 5.1 region. So, thanks. Can't we do this yet? Very old mitts. I'll just show you anything before. A bank, the Labour Office 3.5, was stuck in more than one way. The reason why we don't have good, bigger, certain coverage for that is because it saw staff of its very costability state. It's more a matter of archaeology than development. In order to build the tree that old, you need to set up a development environment from that era. The modern GCC and other tools just won't cut it. They don't like the code as it was then. Of course, anything on the release branches, as you can say, is only covered master. It does happen very occasionally that someone will introduce a bug on the release branch, but it shouldn't happen or it's on there. It should first have landed on master. From time to time, we hope it doesn't. Not a very important thing to cover, but perhaps we'll recover it in future. Which should you use? Use the point greater depositories than you have, because that will give you an exact result that you want to be had. Only if you're outside that region you have to use as fast depository. There are other historical depositories in which old is on the weekly. Try to use a few more of them, unless you really have to be irreverent. Finally, there is a special depository which some people have used or by any by-section incorrectly, and that is the releases depository, which contains only the official document foundation releases, plus one abstract release for all of them. Don't use that for the by-section. That's not helpful, that's why I adopted it. Right, so, we only have a little time because that's the now the main part of my talk, and to do it effectively. I can't teach you how to do this because it's a sport and not a demonstration. If you'd like a demonstration, please go and find me and I'll show you. What I have to do in this is to give you some ideas and how to think about it if you have to find a regression using a by-section. That is the idea of effective. It simply means you have to find a single commit or failing that sometimes. A small set commit by a single person is also a result. Then you need to get that and the person who produced it. Most importantly, you need to do it in a shorter period of time as possible after the by-section was introduced. Very often people disappear. They leave the project or they go and join a commune or they don't care about their bugs. If you can get a bug to the bugs and introduce it within a few weeks or months, there's a very good chance that they will be willing to fix it. That is something we strive for very hard for QA. Even if you don't get a good result, documenting what you find on the by-section a little bit more will certainly save other QA and develop those time because you've seen your result. So please do. First up, the most important thing for running a by-section is that you need to have sort of reproduction steps and if you don't, then there's nothing to do. Simply send it back to the user who reported it and asked for more details. That's what the need info status is for on the bugzilla. Because you're going to be doing the same thing a number of times, it's helpful at this point to make sure that your reproduction steps are as simple as possible. If you have trouble reproducing it at all, a good thing to do is to start with a version that is as near as possible to the version that the user reported at the time. You can't even reproduce it then and then again to send it back for a point of information. Another important thing to do before starting is to check that bugs still exist on master. Now, if it doesn't, it may still be work to do. It is useful if you find a bug that used to exist, it doesn't anymore, to find out exactly when it was fixed. The reason for this is that from time to time someone will fix a bug tangentially. They fixed it, but they didn't know they fixed it or didn't know for instance that it caused a crash. When this happens, it's a very good thing to check that other bits that has been made or other branches. For instance, if it was fixed on master, has it been fixed, it will release a very good thing to check. So, if you are simplifying or reproducing steps, a good thing to do is to make a test document relating the process as possible. If the user reported that you have to do a dozen things and the final one is the one that caused the crash, test document at the point just before then so that you don't have to delete those which time you use. That's another one that comes up from time to time. Reproducing a bug here by running a macro. You'll get very bored of going through here. I'm teaming on a bit of a good thing after I've moved it for a variety of reasons. Hold on to that point of information to mud, platform to be on one and orchestra to be able to find one. They're also starting to move it at no much later. In 15 minutes, library staff will no longer be available in the library so that's a good thing to do. Welcome to stay in the area and use the library on your own. Thank you for that information. So, if you have to run a macro to reproduce a bug and it caused the crash for instance, you'll quickly get very bored running through the menus and dialogues to find the right macro. A quick shortcut to do that is you can insert a button to a document which runs the macro at that point and press the button and that's all done. Another common thing to reproduce a bug is that there is a problem with loading and saving certain file formats. There's an excellent shortcut for that which is to use the command like a conversion tool where you headless, it's a useful switch or some historical version that's not necessary anymore and to simply convert to the relevant format you're in for fun. Hello, a question on my instance. It's just more a note that in most of your cases this is not relevant when you use this command like too you have Librofist has to map the file main extension to a filter and this code is not sharp with the code that map the file extension to a filter in the file savers dialogue. So, sometimes it happens that the file savers the result is different compared to this converter. Something early stage goes on and there's something to watch out for. So, you have to apparently take care that the resulting file is in the right format wasn't something I was aware of. Very good, thank you. It should work most of the times. But sometimes what you can do is you can also specify what filter you want to use. Yeah, you can actually say and you can specify that. You can actually specify the filter name as well. Okay. Thank you. Moving rapidly on because we all like to get to do it. So, next part, sitting on but it was said you need to find your commit that works and one that doesn't. A very important thing to do is to find a specific epoch which contains the bug. So, you can narrow it down to having it introduced in the development period or a certain release. There will be a a a a a a will be a specific fine grain for most of theeters now between all point 1 and one point 0. One important reason you should do that is that it does also happen from time to time. The second bug that is more than once or one that looks very like it because the gift by set will only give you a single result manifest i'w gyda gweithio i'w gwybod bod ddweud dros 12 oed yn gwneud eich bod fyddeidiaeth yn y gyfysg botherau. Mae'n rhoi'r tallydd yn fawr, mae'r ddawid i'ch gweld i'ch bwysig, yn fwy o dda iawn. Wrth fe ydym yn dod, fe ydym yn ateb i'r ddweud i'ch ddweudio i yr bobl yn restrictions fyrrau. Roedd am yn wych chi'n ddeddiadu. Rwy'n ei chael y bach yn ffonsio y maen nhw'n gweithio â'r gweithredu. Mae'r bach yn mynd yn ei ddifamol, ac mae'r bach yn cael ei ddifamol, ac mae'r bach yn cael ei ddifamol, ac mae'r ffonsio'r bach yn cael ei ddifamol. Felly, ydych chi'n gallu bach yn gwneud hynny, mae'r gweithredu yn gallu bach yn cael ei ddifamol, ac mae'r bach yn cael ei ddifamol. Mae problemau is white lies that there are hundreds of commits you need to enter testing or hundreds of those individually before it will tell you there's nothing more to test. You usually don't want to do that it will take a long time. What you should do when you find more than three or four skips have happened in a row is to stop and start again. You turn in a single section into two so you now want to find the point at which the originally ymgwrdd y byd ymweld, yn clywed i'r pethau'r cyhoeddion, ac esud yn ddiddordeb yn y pethau'r cyhoeddion, ac mae'n gilydd yn gwybod, ac yn ymweld i'r bwysig o'r ddiddordeb. Felly, ydych chi'n gwneud ymweld, ym mwy o'r gweithio'n gwybod, ac oherwydd, o'r bwysig o'r cyhoeddion, rydych chi'n gwneud bod nesaf, Again, from bitter personal experience, if you don't do this, you may or may end up commenting the wrong person as the guilty party. There are a couple of reasons this can happen. Most obvious is your error. If you type good when you make bad, then you will land in the wrong place. But it can also happen and does happen that you don't notice that the vote will be reducing. Is it quite as good as you thought? If it crashes, maybe it only crashes 9 out of 10 times. If you don't notice this, you may get 9 on the wrong commit and later on buzz. So it's very good at the end to recheck that the result you've got actually is the correct result. When you get to the end, there are one set of things that are possible as your result. The very best one, the one we like most, is that we have a proper fine-grained up-bridge and infancy commit. We concentrate the order of the job done and finished. If we get a range of skipped commits in the fine-grained up-bridge, it's also possible that if they're all by one person, that person has done a set of commits together but didn't bother to make sure that they can all be built individually, that if that's the case, then we can still send it to that person. If we are in a sparse region, we don't have full coverage, then someone will still need to look more at the results later. Unfortunately, but this is still a useful shortcut for whoever is going to do the next piece of work. Finally, if we have sparse results and a range of skipped commits that is probably a long build, maybe they're in trouble, let's take a look at what happened to the track down. We really hope we don't get that. So, if we found our perfect result, what we need to do is to adjust the fields in Barcelona, two possible things can happen here, because just for some times, when a new feature is introduced, a new feature and a bug with it arrive at the same time, we don't consider that a regression. If the feature doesn't exist, or the bug is not really a regression, and somebody will complain about that, it's up to any part of the data. Probably, but that's not what's going to happen. So, we have spent... I'm going to take it to mean that I'm not going to grab this up in five minutes. It's fine. So, for this specific case, we have a special blackboard tagging bug, which is the implementation error, which is just for the case when a bug and a feature arrive at the same time, and there's no earlier version of the word. We can sort of find this using the blackboard section, but the tags are not available. So, a small thing to note is that in the repository of the author and the committer of a commit may be different, and you need to make sure you're set to the right one. Sometimes the committer is a reviewer, and he really wants to be sending it to the author. Generally, you want to make sure that, also, that you're not sending your bugs to me because they're creeper-builders. They'll be mentioned there, but that's not the right answer. The correct author, the committer, are in the body of the commit message, which is copied over from the source for the trick when the bit of that repo is built. Also, sometimes also, because less so now, for reasons that should be obvious to anyone who's been paid attention, that you have committed a copy over from an open office, it's not a good idea to contact the author in this case. Usually, addresses are at Apache.org. However, given that Armand Le Grand is now working at CIP, there is now a major exception to this, and possibly now a good thing to copy to him again. Armand Le Grand is, of course, the major previous consciousness to open office. So, in fact, a large majority of the copies that were due to have his name. If you're trying to find who to send them up to in Godzilla, not everyone uses the same email address, but both are useful features of this, just like their name in the ceasing box, very likely the correct address will pop up. A few people don't have a password on but certainly, in this case, just want to do it again in a minute. Now, typical instructions for what to do with the bit of that involves seeking results of a bit by Z-Lock or on a... If we apparently damage the bit of this, it's probably useful to do that, don't bother to know what to do about it. We can't... An important thing not to do is to add the bicep to the keyword, which is purely for the case when we have identified a single commit or at least a single person. If you leave that off and it makes it perfectly clear that it's still work-ded on this bug, then QA can find a letter to carry on. Unless you are certain, you are reasonably certain who has introduced a bug to OCC. Especially if you are dealing with a sparser across a tree, someone will be mentioned on the result but considering that most of the source commits aren't mentioned at all, they probably aren't the right person so we don't know what to do with that. In the case earlier, I mentioned that sometimes you need to know how to find a bug that's fixed. If a bit by Z-Lock doesn't like to do this, it's backwards. It always wants the bad commit to follow the good commit but normally, if you think of it, the good one is the one that works. So you have to turn your brain around in this case and make the initial good commit for the one that has a bug and the bad commit for the one that's with it to be fixed. I find it useful to hold shades here in mind when I'm doing this and to repeat myself. Fave is bad or foul is fair. Each time I'm typing good or bad, just think of Macbeth. Specific tips or specific purposes. Anyone who uses the old 4-3 or learning tree which goes a long way back in time, it still has its uses. Many say that it has a few small issues. In some commits, there are files in the report of tree which shouldn't be there and you will find that when time to get by set or get by set bad, it will refuse to continue and move out of the way. In simple bisections, there's going to be a lot of time so you probably want to take a short cut. You might want to delete them if you really want to. If you're certain that there's nothing sitting in the directory which you really care about, you can simply type instead, getCleanLinesDFFX which will be set through a repository to how it should be and also delete anything in the directory that was not in the repository. A useful tool which a lot of people don't have, git by set visualise, shows in graphical form the state of git by set. You can also access the same tool using the git pay command and it takes all sorts of git-like commands to show ranges of commits in graphical form. It has its uses. Another useful case for using it is if you get to the end of a bisection and you've only got skip results, you didn't find a specific commit, git will tell you which other skip commits but it won't tell you in specific order that it will run order. It's not useful. If at this point you use git by set visualise, you can quickly figure out which is the first and which is the last in this range and it's not a useful thing to tell people who need to look at that result. Git is not generally capable of moving forward in history. It likes to go backwards but there is a very useful little command which I'm going to give you here. If you want to move one forward in history towards master or towards later in the days of the binary by set repository, you can do this and it will go forward in time. It's useful to do when you are rechecking a result might want to go forward to backwards a couple of times to check it. I made these into little shell scripts which I call git forward and bb forward. I use that almost every time I have to do it a bit by section. If you would like any further information, there is a large and moderately organised collection of information on the Document Foundation Weekly. If you'd like some more personal help, please come and find me anytime on the LibreOffice QA policy channel. I'd be delighted to help you. There are other people in there with some experience as well. That's it and we can go for our supper. Any questions, no good? Please. I always wondered why is it called bb set? It's short for binary by set. I thought a section, a section and by set was binary by set. So playing git by set works on the source repository. For each commit you test, you first have to build from source. That can take a long time. Even with quite good consumer hardware, that can take an hour to build a LibreOffice and you might have to do that 10 times to find your bug. By building binaries ahead of time and giving them to everybody equally, you simply have to check out the binary for the correct source commit and it will take a few minutes rather than an hour or probably several hours unless you've got really, really good hardware. So the binary is not exactly two but it's actually the source of the binary. So the one buy is for the binary and the one buy is for the binary search. You can spend it to the binary binary section. If you want to see this in action please drop into the hackfest and I'll be delighted to demonstrate. OK, thanks very much. Let's go get some supper.