Zion Johnson, one of the top offensive linemen in the draft this year. I've got to know you're Davidson, good school, play nice football, things are going well. Takes a lot of guts to walk away from there and go to Boston College. What led you to do that? I would say a lot of people may or may not know this, but Davidson College doesn't offer athletic scholarship. So for me, I wanted to try to go somewhere, you know, whether it was higher SES or, you know, maybe if I had the opportunity to go to a FBS school to go somewhere I would go on scholarship. But when I went in the portal, you know, I was actually surprised. I got a lot more interest than I thought I would. You know, one of the schools I thought about going was South Dakota State. But, you know, I looked at Boston College. I had the connection with the coach there, Phil Troutwine. You know, he coached me. He recruited me to Davidson and they're a great academic institution. So, you know, for me, it was a no-brainer at that point. You're still a Davidson guy at heart too and a Boston College guy. Absolutely. Absolutely. Absolutely. So, when you go to BC, the development and everything, was there a year? Was there a time where was there a moment where things really took off where you said, hey, I can really, really do this? Well, my outlook going in is, you know, I felt like a lot of people expected me to, you know, register at the year develop. But for me, I wanted to go in there. I wanted to play. You know, I felt like I had that opportunity and wanted to do that. So, I came in there in the spring. You know, I had to submit a waiver to play because this was before you had one year to transfer. You'd have your eligibility. So, I went in, developed throughout the spring. I think I played a great tackle. You know, a position I never played before. You know, I was on the two deep. And once my waiver was accepted, they moved me to left guard. And I started competing with the left guard there. It was a fifth year senior. So, we rotated all throughout the first six games of the season. And then I finally got the opportunity to start, you know, seven games in. What is it about you, athletically, that makes you an effective offensive lineman? I mean, I think one important thing for offensive linemen is you need to be able to anchor in the past. You need to be able to sit on ball rushes and, you know, stop penetration. I think I do that fairly well. Playing tackle. I mean, you're not the tallest guy in the world. And you certainly project in the NFL as an interior guy. How much does it help you though, in this whole experience, that you have played tackle on both sides? Oh, absolutely. It helped me a lot. You know, at tackle, you have a lot more opportunities to block very athletic defensive ends in space.  You know, you get that experience being isolated, you know, being one-on-one with good players. So, you move back inside. You know, it kind of feels more natural in pass protection. Snap very naturally. Is that something you've done much in your career? Not really. It's something that I've been focusing on, though. You know, I've done a lot of under center work at Boston College. I played center in the spring game, pretty much primarily under center. But I've been working the gun snaps in the off season, trying to get better at that facet of my game. Feel like a center from your mentality, meaning a guy that can handle a big guy on top of you and run the whole show. Do you like that aspect of it potentially? I do like that aspect.    I like learning about defenses and the offense and having control of the show, getting in to point the IDs and, you know, say where the protection's going. That's really a part of playing center. That's really enticing. I like. What's the most important thing that the NFL team that drafts you should know that they are getting inside Johnson? Well, I would say I'm a reliable guy. I'm someone who, you know, you can count on to know their assignment. A guy you can count on to do the right things outside of the facility and inside the facility. And, you know, along with that, I'm a guy that's for the team.  I want to go somewhere that with guys that want to win and that are hard workers.


Hi, I'm Harleen Hatterman-Valenti. I'm a professor and assistant chair at North Dakota State University in plant sciences. And I'm going to be talking about a trial that we have up at Inkster. This is the third year that we've done this in collaboration with the Northern Crop Insurance Service on hail injury to potatoes. Recently we've had a number of storms come through and so some of this hail has been very destructive and what the National Crop Insurance Service is looking at is how some of the newer varieties, processing varieties such as Clearwater and Bannock, compare to our old traditional or more traditional processing variety called Russet Burbank. So we have both of those cultivars in the trial and what we've done is we've done various degrees of defoliation, not only the leaves but also the stems because hail isn't very specific when it wants to go and injure a crop, it'll just really macerate everything. So our removal is up to almost 100 percent and then we have this at three different timings to see when is the most important time where if hail hit a potato field it's going to be the most destructive. So we're looking at hail at that tuber initiation stage, which you have your tubers there, the plants trying to go and reproduce with these tubers. We then look at early bulking stage a little bit later but still in the past what we found is that's a very important stage where if a field was to get hailed and severely it can do a lot of reduction in size and your overall yield and quality. And then lastly is that late bulking stage where we found really the late bulking stage, the plant has pretty much produced quite a bit so you're just going to reduce mainly your size on that but it's really important to know how these new cultivars are going to compare with more of our traditional cultivars. And so hope to go and show you some of those pictures of how these plants recover in North Dakota.


HCl is a strong acid. We should be very careful with this. Whereas vinegar is a weak acid. We even eat this. But what is the difference? What makes an acid strong or weak? That's exactly what we are going to talk about in this particular video. See, we have already studied that acids are compounds which when mixed in aqua solution, they increase the concentration of H plus ions. And that's why when I mix HCl in water, this dissociates into H plus and chlorine minus. And it increases the H plus ion concentration. That's why this is an acid. But HCl is a strong acid. Meaning it goes through complete dissociation. This means that if I take 10 molecules of HCl, all of the HCl molecules will break down or dissociate into its ions. I will have no HCl molecule being left behind. In fact, I will get 10 H plus and 10 chlorine minus. That means a strong acid. It completely dissociates in an aqua solution into its ions. And we no longer have any molecules of the acid present in the solution. We will only get its ions in the solution. Whereas if you take a weak acid like vinegar, see its chemical formula is CH3COOH called acetic acid. See, this is also an acid. So when mixed in an aqua solution, this will also dissociate to give us H plus ion. We will get H plus and CH3COO minus ion, acetate ion. But see, there is a problem. This acetate ion is not very stable in its ionic form. It doesn't want to stay as an ion. It will combine with H plus. And it will want to exist as the acid. This means even if you take 10 molecules of acetic acid, not all of them are going to dissociate to give us H plus ion. Even after a long time, you can find a lot of acid still existing. Acid molecules still in the solution. Let's say maybe 8 molecules are still in the solution. And only 2 molecules have dissociated to give us H plus and acetate ion. The rest of the molecules would have dissociated, but their ions would have combined back to give us the acid molecule. Okay? So this is the difference between strong acid and weak acid. See, strong acids, they undergo complete dissociation. Meaning all the molecules of the acid will dissociate to give us H plus ion. And no molecules of the acid will remain back in the solution. Whereas weak acids, they only undergo partial dissociation. Meaning not all molecules. In fact, only few molecules of the acid will dissociate to give us H plus ion. And that is happening because the negative ion that gets formed is very unstable. It combines back with the H plus to give back the acid. Okay? Now this means that if I take equal amount of strong acid, this will give me a lot more H plus ions than the equal amount of weak acid. In fact weak acids, they give us very little amount of H plus ions. And that's why they are less harmful or less dangerous to human body. And strong acids, since they give a lot of H plus ion, they could be very dangerous to human body. Because see, human body, it tries to maintain the acidity of the body. Or the concentration of H plus ions in the body. And whenever it comes in contact with even small amount of strong acid, it could increase the concentration of H plus ions in the body. And therefore, it can harm the human body. That's why we suggest you know, be very careful around strong acids. Later on we will study how to dilute the strong acids and use them safely. But for now, let's look at some examples of strong acid and weak acids. So strong acid apart from HCl is H2SO4, HNO3 and other acids. See all of these acids, they completely dissociate. Meaning you would not find their molecules present in the solution. You will only find their ions being present in the solution. Whereas examples of weak acid, apart from acetic acid, are H2CO3 and HF. And there are some other acids too. See, these acids will only go through partial dissociation. Meaning even if they dissociate most of their ions will combine back to form the acid molecule. And that's why we get very little amount of H plus ions. Now this is something similar that also happens with bases. We have strong bases like NaOH. Now they undergo complete dissociation. Meaning all molecules of the base will dissociate into its ions. Whereas we also have some weak bases like NH4OH ammonium hydroxide. They undergo partial dissociation. Meaning only a few molecules of the base will dissociate into its ions and give us some OH-ion. Now let's summarize the video. In this video we saw that strong acids and bases, they undergo complete dissociation. Meaning all their molecules will dissociate to give us ions. H plus ions and OH-ions. And that's why we will get a lot of them. Whereas weak acids and bases, they will undergo partial dissociation. Meaning only few molecules of theirs will dissociate to give us H plus ions and OH-ions. And that's why we will have very few of them. And we also saw their examples.


Thank you. Hello everyone. So I'm really gonna be really excited to see how this talk goes because I got asked to do it yesterday and I said I would do a talk on the condition that I didn't have to do any preparation So my goal is to teach you the Python object model The method resolution order for multiple inheritance and meta classes in 20 minutes and have five minutes for questions left We'll see we'll see if I get any of that. My name is Michael Ford. I've been a Python developer Well for about 15 or 16 years a professional Python developer for 12 years I started my career in London working on a desktop application written in an iron Python There weren't many people using iron Python at the time. So I wrote a book on Python in action I called the passion for testing Wrote a library called mock which some of you might have heard of and is now in the standard library as unit test mock And I'm now working Having made a few jumps fire both canonical and red hats I'm now self-employed as a Python contractor and trainer But please don't take this as too damning an indictment on my training abilities Okay, so Can you all hear me all right by the way? Okay, I will stop where and can you all see the script? Can you all see the screens? Can you read the code on it? Is it good enough? Okay, great right. So this is a very standard Python class We you can see the code there. We have an initializer not a constructor. It takes self as an argument So the object has already been constructed at this point if you want to over Python has to phase object creation if you want to override The constructor the construction of the object you need to turn off caps lock on your computer and Then you override new which takes the self and any parameters the same the same as in it And then should Dunder new return. Oh, what Tom?  I didn't test this or plan this at all okay so long as Dunder new returns an instance of the class or a subclass of The class the initializer will be called Dunder new is free to return whatever it wants if it returns something That is not a subclass of the class being constructed It will it will not initialize it and this is actually really useful mock makes a useful Makes good use of this technique Mock objects allow you to customize their behavior including customizing the behavior of some of the magic methods like Dunder get item and Dunder set item so that you can use a mock object as if it was a dictionary now These magic methods they're typically looked up on the class rather than on the instance This is one slight area of confusion in the Python object model. So if I do If I index or technically subscript into an object X there Python is going to look up The Dunder get item method on X, but it's actually going to look up It's not going to look it up at all there are fast paths inside the interpreter for that That is how it's going to find get item This means if you want to customize the behavior of Dunder get item you have to do it on its class Which if all mock objects were the same class if you changed Dunder get item on one the behavior of every mock object will be changed so what actually The mock constructor does is it creates a new subclass of mock or magic mock Inside the constructor and returns an instance of that subclass and then you're free to tinker with the class of the mock object customize the behavior of the magic methods without interfering with any of the Without any of the behavior of the others so it looks something like this it doesn't actually do it this way And we delegate the actual construction To object Let's see if that works. It's a long time since I've tried Messing around with anything like this, so it was called thing wasn't it? We should actually find our tea is an instance of New not many use cases for doing that Okay right So what I was intending to talk about is the instance attribute X here We have an initializer which doesn't do very much It sets the attribute X on the object on on the instance and Perfectly standard Python when I look up the attribute X on the instance t we get back the value three Actually the full rules of how Python does that look up are way more complicated than you might imagine Mostly implemented in object dot Dunder get attribute Okay, so that's straightforward. We have an instance. We have an instance attribute. We fetch the instance attribute What about when I do something like? the also entirely Un Astounding tell me X. I'm looking up a method on that after on that object We get back an interesting object But so let's take a step back and look at a bit of what Python objects are So you've probably heard it said that Python is built on top of dictionaries dictionaries hash tables associated for arrays keys mapping to values In Python namespaces are particularly important and namespaces are names mapping to objects and We have an object here and We have a set of names some of which are valid and some of which aren't So Along with this object we have a kind of namespace that goes with it which stores this mapping of attributes to the corresponding objects behind it the The corresponding object that the name t.x there points to is the integer object three So under the hood and this is probably not news to many of you There is an actual dictionary Storing these attributes and it's the Dunderdict attribute. It it's not considered Particularly private. There are lots of use cases for playing with this directly particularly for working around the descriptor protocol We can see this is a real dictionary. I can look up the X attribute And I can do things like set arbitrary new attributes and now my t object Has a y attribute so operations on the attributes of a Python object correspond Directly is very much the wrong word because there are lots of slips in between But it's not too much of a lie to say that they correspond directly to operations on the underlying dictionary So this is if what I like to call When I've had a bit more time to think about what I'm going to say Python from the inside out This is not thinking about Python objects when we write classes when we're designing code classes and objects they their ideas they Represent something conceptually it might represent a socket it might represent a file it might represent a worksheet in a spreadsheet and we think about the object in terms of the concept it represents and a well-designed object will have an API that corresponds as Closely as possible to the thing it's trying to represent If the idea your object presents and the way you work with that object map well together It will have what feels like an intuitive API But actually still what we're working with is still Python objects and all objects have the Python object model in common So this is this is objects turned inside out. This is looking at their behavior from the inside So that's straightforward But you'll remember mere seconds ago. I was looking up a method and I'm pretty sure That my dictionary here has no tell me x entry It's not that So the attribute look up is not as straightforward as just look look at the object dictionary find what's in there and unfetch the method and in fact It's not a problem because we know where that method lives every object In Python we say Python is fully object oriented. That means everything is an object That means everything in inherits from objects So what do we got? We've got our thing class here A class is just an object. It's just a Python object The consequences of this is if I ask Python is thing an instance of object It will say true that will be true for anything you can find in Python any first-class object And this is not actually this is not just theoretical. There's certain object behavior You see that Representation they when when you display an object at the interactive interpreter you get a representation of the object Which includes the class name some information about where it came from and an ID which is a proxy for a memory location That is actually the magic method done to repra the representation And it's inherited from object. There's a certain amount of behavior including things like object dot get Done to get attributes which implements the whole attribute lookup protocol that your Python objects get just by virtue of being objects That's what it means in Python to say everything is an object. There are some really interesting consequences of that You can do Really dumb things So here I'm creating a a list It holds a built-in function apps. It holds the math module and it holds the type error exception And please don't ever write code that looks like this right and it all does What you would expect and this is the bit where you're going to put your hands in your head Exceptions are matched at runtime when the exception is raised So Python will fetch the exception type. It's looking for from the list Everything is an object Where have we got to? okay, so I Said that's Instance attributes are stored in the instance dictionary, but we can look up attributes which are not in the instance dictionary So the rule for attribute lookup is well if it's not in the instance dictionary, where is it and? every object Has a link back to its type Everything is an object and everything has a type and classes are just objects and they also have a dictionary And this is where class level attributes live class level attributes are attributes that is shared by all instances of the object so you can have arbitrary attributes and Methods now that we're in Python 3 and there's no such thing as an unbound method Methods are just functions that live in the class dictionary. Oh, what's it called? What did I call that silly method? Right, however, because I did this up on the subclass trick I Get to do something like There are many this is the thing with Python. There's only one way to do it is a lie Okay, and you see I've just pulled out a function object interestingly if I look up the method on The from the object I get a bound method back again back back something different and this is um That's the descriptor protocol functions are descriptors. They have a done to get method I'm not going to go into that but what it means is when Python finds via the attribute look up when it finds the method What it does is it it? Wraps in self and returns you a method where self is already bound in partial application. So tell me x Takes no parameters However, if I do this which gets me a function object What's the first parameter Self obviously you have to bust in explicitly because we're working directly on the underlying function So the rule becomes a little bit more complicated first We look in the the instance dictionary then if it's not found there. We check the the class dictionary Not quite true the descriptor protocol makes it more complicated. Okay, right Um We don't have a lot of time left right so meta classes in five minutes So the rule is you check all of the base classes up until you find it the descriptor protocol overrides that so properties override instance attributes So if you just add the phrase it's more complicated than that to everything I say we'll get on fine Okay, right everything is an object every object has a type Classes are objects. So what's the type of a class? What is its type? The type is its meta class and how do we instantiate objects? We instantiate our objects by calling their type. So how do we create a class? We create a class by instantiating its meta class and the default meta class is type and what will boggle your minds is That the type of type is type type is a type Okay, so type is the default meta class type is what creates classes What you need to do to create a type is you need a name you need a tuple of base classes and you need a dictionary of members And so that I just created a cloud. This is what Python does under the hood It executes the when you enter a class statement it executes inside the body of the statement the bot sorry inside Executes the body of the class creating the functions that creates a dictionary of the mapping of all the class attributes And then the meta class is called with these things the name the tuple of base classes and the dictionary of attributes Created from executing the class body. This means that that class body is a very interesting scope That doesn't behave quite like other Python scopes, and I'm not going to go into that What it means so there that's a meta class in use a class factory I don't think I'm going to get to the method resolution order probably So the typical way to create a new meta class Is you just inherit from type you override whatever behavior it is That you're interested in So here I'm underwriting done to get item on a meta class Now we have in Python this funky syntax. Is it meta class equals? now There's nothing inside the body of the class because I've set a meta class as long as I've remembered the Python three syntax correct Python is actually going to call my my new to create the class now I could have made that more explicit by By putting them something in in the call But the interesting thing is remember when I said earlier that the protocol methods are looked up on the class So here we have an object its type is new when I subscript it The type of foo is New done to get item on new is going to be used So here we're getting behavior from the meta class on the class object and the meta class is not in the inheritance hierarchy Which is an interesting corner of the Python of the Python object model? It's interesting to know that class decorators and done to in its subclass particularly are Good reasons to never write meta class But this is the machinery that's at work under the hood everything in Python is an object every object has a type classes Objects their type is typically type the default meta class responsible for creating types But you can override that and there are many reasons why why you might want to override that but I can assure you far more Why you might not want to do that? Okay, I Hope that was understandable. We're going to be coming up for question time Very shortly. I did promise. Let's look at the method resolution order So the the ret the attribute look up order that I mentioned before First look on the instance then check the class and then maybe check any base classes until you find the attribution It's returned that's straightforward in the presence of single inheritance But here you can see I've got a class a a class B a class C A and C both define a foo method and class F Inherits from D and E when I instantiate F and call foo what is going to happen? Which foo method is going to be called the fact that it's even slightly annoying to work out is another Reason why you shouldn't use multiple inheritance mixing classes are the only valid Reason so in this case It was actually the the a that happened I'm Instead of taking questions what I think I will do is I think I reckon I can possibly explain that in five minutes Let's have a look so F is an up a class class object We've explained that in the face of inheritance Python has to walk up the inheritance hierarchy in order to find the method How does it do that in the face of multiple inheritance where you have an inheritance graph? And the answer is that Python constructs a method resolution order the MRO it linearizes and the algorithm is actually called the C3 linearization algorithm, and I'm hoping I haven't talked too much nonsense If Mark is at least not scowling at me. I'm not doing too badly and pipe This is a linearization of the method resolution order Python will walk up until it finds the first one What this means is it's perfectly possible. Oh, right. How does it construct? What is the linearization algorithm the linearization algorithm has essentially two rules the rules are that children must be checked before? Parents and that order must be preserved. So in this example D should be checked before E and D should be checked before Before B and B should be checked before a because children must be checked before Parents Okay, what it means is it's perfectly possible to create inheritance hierarchies Convoluted had an inheritance hierarchies that aren't possible so If I reverse the order of these you have E and D you'll see an exception which you will hopefully Never see in practice. Oh No What did I do? I'll make it I'll make it easier. I'll put a at the front and rather than spending at precious seconds debugging this Right to type error cannot create a consistent method resolution order the two rules that I described are that children must be checked before parents But that the order they are declared must be honored having the order They're declared honored is useful because it means you can have a mixing class that you mix in by multiple inheritance the only good reason to use multiple inheritance and your you declare it first and your Overridden one will always be called before The main class and you use super this is cooperative multiple inheritance if you're mixing class uses super to to make the call up the inheritance hierarchy super will actually jump sideways because the The method resolution order in order to honor these children must be a be called checked before parents and the order Order matters you will often find that the next in the method resolution order is not up the hierarchy But a sideways jump that was fairly disorganized But I think we maybe kind of got there Thank you very much Do we have time for any questions? We have time for one or two very quick questions Hope it's I hope it's quick Abstop based classes and met classes usually considered black magic. Yeah. Yeah, they are so My question is do you believe that? Python programmers should leverage them use them. I think I think it's very useful to understand them Because you're understanding Python.  So it's more of it. So no not something you should leverage Particularly, but something that's worth understanding Well, thank you very much Can you hear me I can hear you that was entertaining and illuminating I have a question about the Attributes of the object which you showed were Correspond to a dictionary. Uh-huh dictionary is itself an object, right, right? Yes. Yeah, how do we get objects all the way down? I guess you could say that it finally ends in type where if the type of type is type What creates type and the answer is somewhere the interpreter has to cheat and it creates a C-struct and pre-populated and type is never instantiate it so, you know, there is a bottom to the house of cards So please let's everybody thank Michael. It was extremely great talk last minute live demo worked perfectly so Thank you


But what I would say for me, the hope lies, is in two things. One is that I think the young are very, very interested in either the kind of action that you talked about, the kind of protest action, and it happens all over the place in many ways. And also in the NGOs, the non-governmental institutions that do now function around the world and do far better work than I do on a daily basis when I'm writing. The other area that gives me hope is that when I talk to young writers and indeed young artists, they will say to me, I mean, I was in conversation with, public conversation with a wonderful writer called Zaidi Smith, who likes to encompass various traditions in her work, and she says part of her labor, part of her work, part of her life is constantly to carry on conversations with the writers of the past, with the writers of various traditions or artists of various traditions in the past. And that conversation, that ongoing conversation, feeds into the work that she does now. And I think that's true for all of us and for all artists. And I find hope in that. We haven't had a complete rupture despite our culture wars. We talk a lot about artists, but we didn't talk much about the masterpiece itself or the painting. I think it's also very important to know. I think, I believe, maybe it's too mystical, but the masterpiece itself has its own energy, its own life. Once it's created, it leaves its, it cuts its connection with its creator. And it continue living and changing and evolving in our world. So, and I think that the greatest possibility that we have with the masterpieces, with the art of my father's films, and I'm bringing the testimony of the people I met working on the foundation, meeting the people that was saying that the film's art, my father's art, can change them. They change their lives. If art, the masterpieces artwork is capable to have an energy to change someone's life completely, I met people who were scientists or engineers. They became priests after seeing Tarkovsky's films. So that's something very powerful. And I think it's not only regarding the examples, I think, that all over the world and it could happen with all the paintings and artworks and musical pieces. So if we have this, we still could have hope. And this film is about the hope nonetheless that the situation was so grim and my father's in my documentary is very negative about the reality of things. But he never left the idea that there's always something that we have tend to. Until we leave, we have to evolve spiritually. And that's actually, I think, the dedication he gave to all of us. Well, the film dedicated to personally, but it's dedicated to all the children coming afterwards. This idea that we clearly are imperfect, you know, but there isn't much more than we can do to work on those imperfections, work it collectively, know more, understand more, also about what we, about these imperfections. And for me, that actually is the greatest source of hope. It's this fact that we can learn as a world. Clearly, we do that with ups and downs. Art plays a very important role in the sense, for me, it's kind of an antenna. It's a radar screen where you see things, you know, blips of a very, very distant future. But I think what we do need is this sense of, I would say, it's not ownership and certainly it's responsibility. It's not that time pushes us, you know, unwillingly in a certain direction. We, you know, it's all, it's self-inflicted, right? It's, this is the world that we create together. And the hope is by understanding more about it, I think, about ourselves, about how we interact, how this all came to being. That, and I think, you know, in the end, very, very, very basic human skills of patients, trust, dialogue, things that are as important now as they were in distant past and distant futures. I think that's actually the way that we can carry that responsibility. Fright was practically people of Nietzsche in many things. And Nietzsche, that in his gay science, really his business, through his madman, who was the herald of the death of God, aren't those churches just tombs and tombstones of the dead God? And I ask, I ask it the same question in the pandemic, in this lockdown, when the churches were closed, I wrote a book time of empty churches. And I ask if the church, if the Christianity will not have a revival, but not this revival in this Pentecostal, evangelical way, to go deeper, to go deeper. So it may happen that the churches will be just the tomb of the dead God. But the empty tomb has, in Christianity, also another meaning. Absolutely. There are two angels saying, why do you seek the living among the death? So we shouldn't seek the living God among the death in the tombs. We should go to the gallery to meet him again. And I think the face in the resurrection, it is the courage to seek the living, to seek the Galilee of today, to see the living, the resurrection, who is absolutely transformed. So the resurrection is not to go back. Some revival of the dead corpse. It is the surprise, absolutely surprise. And I'm saying absolutely new. And also in the gospel, the nearest and nearest of Jesus are not able to recognize him, Mary Magdalene, Mimic Gardener, and so on. And he's absolutely surprised. And the Apostle Thomas, the patron of us adopters, he recognized him by the wounds. And I think it is the sign. We should recognize the living God, living Christ, living culture, living spirit. They call it the wounds. Because if we ignore the wounds of our world, we have no right to say, my Lord and my God. And there are the illusions, but I think the wounds of our world, they are the place we can meet the living God in anonymity and as a surprise. And I think the heart is doing this. And practically all the films we have seen, it was this topic, the wounds of our world, they are the place we can recognize something sacred in an absolutely new way.


I love the Sacred Headwaters Initiative. It speaks really deeply to me because in my research into climate change and the ecological crisis, I gained expanded appreciation for how important the primary rainforests are to maintaining planetary health so far beyond the amount of carbon that they sequester and store. That is, if you look at them only through that lens, they're not that important. You know, you could cut them down and plant tree farms somewhere else and you'd be carbon neutral. But the role that they play in maintaining Gaian physiology, the physiology of the planet, is like the carbon aspect is one percent of that or less. Much more important is the water dimension. So these tropical forests, in fact any forest to a large extent, and wetlands too, but especially these tropical forests, the rains come and because there is such dense life when the rain falls, it doesn't wash away the soil, it doesn't run off, it all soaks into the ground and gets absorbed by the plants and transpired back into the air. When it gets transpired back into the air, as it cools, it creates a cooling effect. When water evaporates, like when your sweat evaporates, it cools. So it cools the surface temperature. In fact, in Kenya, they've compared areas that were deforested with areas that are still forested, which sadly is not very many. And so same topographical conditions, everything the same except one is forced and one doesn't. And the forested areas will be like at 19, 20 degrees Celsius. The deforested areas will be at like 40 degrees Celsius. So if we're talking about global warming, I mean, here's something that gets ignored, the or kind of written off as a heat island, that forested areas are a lot cooler because of transpiration. And if you say, well, that's just a heat island where it's been deforested, I mean, that's a scant consolation for turning the whole planet into a heat island. So anyway, so the water gets transpired, creating a cooling effect on the surface floats up into the air. And then it condenses again into clouds, especially over forests, and especially, especially over really healthy forests that have not been disturbed because the forests actually create compounds and even bacteria that seed the formation of clouds. So there's another cooling effect as the clouds reflect sunlight back. But also what happens when the water condenses, it creates a low pressure zone. And the low pressure zone is a biotic pump, it's called, that pulls air into it. It's like a vacuum that pulls the air into it from whatever is adjacent to it. So if you have a continuous forest stretching all the way from the Atlantic Ocean into the heart of South America, say, then you have a conduit of ocean air into the interior. In Brazil, they call it the Flying River. So it brings water all the way into the interior because water in a forest trans evaporates even faster than over an open ocean because of the leaf area index. There's many, many layers. So this is a biotic pump that is crucial in maintaining the streams and currents of the atmosphere and I think even the ocean. So it basically maintains the flow of water on this earth. So as you destroy the Amazon, then the flows get disrupted and water, air currents no longer go where they went or they fluctuate around a lot. Like it's like the, it'd be as if you were, it'd be as if you had, try to think of a good metaphor, like a garden hose that has perforations in it that's irrigating something and then the plants that hold that hose in place get disrupted. Like that's what the rainforests are. They hold the flows in place. Global warming puts even more stress on these garden hoses. When they get, when you're putting even more pressure through them and they're not held in place anymore, then they start to ride around and they don't bring water where it's supposed to go. So yeah, so if you cut down the forests, then the water doesn't soak down anymore and get transpired. It doesn't feed underground aquifers and springs. It runs off, carrying the soil with it, causing all kinds of damage downstream and weakening the biotic pump. So you have then flood drought cycles where once you had extended rainy periods, the floods get worse, the droughts get worse and we've seen this happen all over the earth and you can replant forests which over time can like tree plantations don't do this nearly as effectively as as healthy living forests. Tree plantations are not alive. They have living trees in them, but they're not themselves alive. They can only become alive over a long period of time. So that's just, so the water lens helps us appreciate how important the sacred headwaters of the Amazon are.  It's that important. Would humanity perish? Maybe not. Maybe we would all live in bubble cities with algae pools to make oxygen, carbon-sucking machines, air conditioning, synthetic food grown in vats, and beautiful digital displays of the nature that has been lost. What if that is a possible future? What if this isn't about human survival? What if we have, what if this idea that climate change is going to make us change our ways? We're going to have to change now. What if that's not true? What if we face a choice of what kind of world do we want to live in? Not whether we're going to live. What kind of world do we want to live in? Do we want to live in a concrete world paved over that's a giant strip mine and garbage dump? Or do we want to live in a healing, vibrant world full of life where you can see the sea turtles, where the beach is littered with shells, where there are frogs and turtles in the ponds, where you can drink from a stream without fear, where you look out and you see not one or two whales like today, but thousands of whales covering the ocean surface when they're missed. We can choose what world we want to live in. If we want to live in a living world, if we want to be in a community of life, we have to start treating the world as alive, especially those deep reservoirs of life, the sacred places, the heart of the Amazon, which in a sense is the heart of the planet, not the lungs of the planet. It's the heart of the planet, the beating heart of the planet. If we choose life, if we see the world as alive, then and only then will we be able to serve life.  If we see the world as a machine, we will create a machine world. So we are choosing not only how we see the world, but we are also choosing who we are. And that's why we have such a strong sense that the ecological crisis is also a spiritual crisis, a crisis meaning in this case a crux, a crossroads, a choice of what path we are going to take, who we are going to be as a species and even as individuals. What are we going to serve? The import of the climate crisis goes all the way to that level. And really climate is to narrow a framing for the choice that we face. It's a choice between life and death and not our own life and death. Because as I said before, humanity maybe, theoretically, I don't know, could survive on a dead planet. But do we want that? It's these deepest, most undisturbed parts of Earth where the, not only undisturbed ecologically, but undisturbed culturally, where there is still a communication, an intimacy between the people and the land, such a deep intimacy that we don't even have the conceptual apparatus to understand how deep that connection is. Those are the places where the dream of the planet is held. That's like the innermost thoughts of Gaia that have not been disrupted by all of the systems of modernity. We have to draw on those places in order to construct a world in their image, in order to participate in the construction of a world in their image. That's a more accurate way of saying it. In order to be part of a healing where that deep knowledge held by the cultures and the land and the water and the trees and the animals and the biota of these deep reservoirs is able to spread out once again across the Earth. It's held in very few places now. The deep Amazon, the deep Congo, maybe a few other places, those are such precious treasures. Every place is sacred, but most places have been disturbed. That primordial knowledge and the long-held dream of the planet is especially strongly held in the sacred headwaters of the Amazon. I'm sure that I can't frame that scientifically, but when you look at images and have the conversations with people who have been there and go there yourself, and I'm not saying you should just go there yourself, some places you should not go unless you are invited and go through a transition like an airlock to step across the threshold to go those places. This is not spiritual or ecological tourism. This is like you wouldn't penetrate the heart of a human being without the appropriate preparation. This is the same, so the best way that we can serve these places is to protect them. This is one of the most important things we can be doing on Earth right now.


Hi and welcome to the session. Let us discuss the following question. Question says, find the values of the letters in the following and give reasons for the steps involved. Let us now start with the solution. First of all we will rewrite the given puzzle. It is 3a plus 25 gives p2. Now we need to find the value of two letters that is a and b. Now one digit of the sum a plus 5 is 2 in one's column. Now clearly you can see here in the one's column sum of a and 5 has the unit's digit as 2. Or we can say one's digit. Now this is possible when value of a is 7. We know that 7 plus 5 is 12 and one's digit of 12 is 2. Now 10's digit of 12 that is 1 is carry in the 10's column. Now we can write for a equal to 7 sum a plus 5 is 12. Now we can write 10's digit of 12 that is 1 is carry in the 10's column. Now adding 3, 2 and carry 1 we get 6 and we know that sum of 3, 2 and carry that is 1 is equal to b. So we can write since 1 plus 3 plus 2 is equal to 6 so b is equal to 6. So we can solve the puzzle as 37 plus 25 gives 62. So required value of a is 7 and required value of b is 6. So this is our required answer. This completes the session. Hope you understood the solution. Take care and have a nice day.


Yeah, gonna dive into this pretty quickly and try and do, I think I was given about an hour and a half. I think is what we're set for time, so we'll try to get through here pretty quickly. And there we go, all right. So like software delivery itself has never been like more critical to success of an organization in a business and pretty much every industry. You know, it's what really kinda sets, you know, how well you can perform in that, really sets you apart from the other organizations and other companies that are out there. But those expectations for like delivering something that's high quality have only gotten higher. It used to be that there'd be the smaller groups of people that would have a really high performing team who got the Netflixes and such. And now that's become the norm. And so those expectations have made things a whole lot more difficult, I think, for a lot of engineering teams. But also at the same time, like the landscape of those tools has gotten bigger and bigger. Like this is the CNCF kind of cloud puzzle. There's probably one way to look at it. And in fact, somebody should make this into a puzzle. It's like more and more complex. And this keeps changing, more and more things keep getting added to this. So how are developer teams supposed to kind of figure out what is really that necessity? What do they really need to succeed and beat out the competition? So hi, ladies and gentlemen, my name's Jeremy. I am a Devereux and Community Professional. The reason it says independent is because I am looking for a new job. So if you wanna talk about that and what that means, we can chat later. Nice little plug and you can find me on Twitter. All right, so in this period of immense change that we have and the global economic uncertainties that we've all kind of felt over, especially over the last couple years has presented a lot of impacts for companies of all sizes, whether it's startups all the way up to enterprises even. But in this environment that we have, the stability and reliability itself has become increasingly important to businesses. The ability to provide that reliable, stable platform to customers has become that critical kind of value metric for how engineering teams get measured and it's only gonna continue to increase as we continue to see things change over the coming months and years. So one of the core tenants of DevOps and a solid pipeline is really this idea of continuous delivery. It's why we're here. It's a CD foundation. If you didn't know, CD stands for Continuous Delivery Foundation. That's why we're here. This is just a very core principle about even what DevOps is. And so a couple of weeks ago, I put out this question of what does continuous delivery mean? How somebody might wanna define that. Anyone wanna take a quick stab? Everybody's still asleep? Good, all right. Well, I got one response. Tracy Miranda, fantastic person. She provided just a really good definition around it's the software development practice in which teams release software that changes software changes to users safely, quickly, and sustainably. It's a really great definition. And it goes very well with what Jezz Humble had to say a few years ago at DevOps Day Seattle, where he talked about like it's that the ability to get changes of all types, including new features, new bugs, or new bug fixes, getting all those things, those experiments into production are into the hands of users safely and as quickly as possible in a sustainable way. In a recent talk given at Fintech, I think it was Fintech DevCon, Charity Majors, who's a CEO at Honeycomb, talked, or CTO at Honeycomb, talked about like a list of these modern development practices. And with the continuous deployment, kind of continuous delivery point, she kind of focused heavily on the importance of deploying as fast as possible and as automated as possible. And so over the last few years, we have seen a jump in companies that are starting to understand that importance that Charity spoke about, but too often we see that's been done with kind of this grow at all cost mentality. And when that gets in place, that's kind of starts introducing more and more challenges and we've seen the cognitive load necessary to keep those systems going and in place has gotten more and more overwhelming for DevOps, Dev and Ops teams in order to put that together. And it's led to a lot of cut corners. I think we've all seen, at least it seems like that we've had more and more outages across a lot of the core systems that we use in the industry over the last few years. And I think it's a direct result of this kind of grow at all cost mentality. So some of you probably familiar of the different kind of industry reports that are out there. There's a state of DevOps reports, state of cloud native, CDF, has their state of continuous delivery report. And they're all kind of great for understanding kind of the industry as a whole, but they also are dealing more on survey data. And so what I'm gonna talk about is based off of a report that was done, it's the state of software delivery report that was done by a company called CircleCI that kind of dealt with actual raw data and kind of able to take that along with what some of these other reports go on survey data and understand actually what's happening with actual verifiable anonymized data. So before we kind of even get dive into some of these metrics, I wanna stress like there is no one size fits all for metrics because everything depends, which is a common DevOps answer, it depends, depends on what you as a company are doing. What are you building? Who are your customers? Is it more internals, more external? Like there's a lot of things that depend on that. And so there really is not a one size fits all. So kind of the four that we're gonna deal with are duration, mean time to resolve, success rate, and then throughput. Those are the four that have been identified as kind of CICD benchmarks for what a high performing team would look like. So and then I'm also gonna talk about the optimization steps, some of those that would be necessary in order to take that strategy and input a lot of these things in place in order to get to that kind of the holy grail kind of way. And hopefully we'll do it without getting concussions as well. All right, so duration as first one here, it really is that foundation of what like a software engineering velocity would look like. But this unit of work that's kind of spoken about in the definition doesn't always mean that you're deploying to production. That could be something as simple as running a few unit tests to kind of get you things on a development branch that you can then start to make some other changes. So it's not just a deploy to production. And so it's kind of probably the best way of viewing this is as kind of this proxy for how efficiently your pipelines are delivering the feedback on the health and quality of your code that's so essential to your development teams to be able to make the changes necessary. And the core kind of promise of most software delivery paradigms, everything from agile, DevOps, it's all speed. And so that ability to take the information you get from your customers or stakeholders and respond quickly and effectively is at a core part of the duration. And this rapid feedback and delivery cycle itself is also just, it doesn't just benefit your organizations and users, it's also gonna add benefit to keeping your developers happy, engaged in kind of this uninterrupted state of flow. But when we exclusively kind of focus on speed, often comes at kind of the expenses of stability. So a pipeline that gets kind of optimized to deliver fast, unverified changes is really nothing more than a highly efficient way of delivering bugs to your system. So it's important to kind of make sure your organization is not exposed to a lot of that risk and your customers don't feel that, is you've gotta be able to move quickly with confidence. So having your pipeline guarded against any potential points of failure, it's important to have a robust test suite. So we'll kind of talk a little bit about that as well. All right, so the duration of benchmark, good rule of thumb that Paul Duvall and his work in 2007 kind of set the stage is keeping your builds no more than 10 minutes. Many developers who use CI follow that practice. And so it kind of keeps you uninterrupted. Anything longer than that can kind of interrupt the flow. That's probably about enough time that once you hit push and things start building, you go grab a cup of coffee, come back to see what the results are, as opposed to maybe 30 minutes or longer and now you're losing kind of that attention span of your developer teams. So among the workflows that were observed in the data set from this report, 50% of them completed in 3.3 minutes or less, 25% were completed in under a minute and 75% under nine. But then the 95th percentile, which isn't reflected here, but it was right around 11 minutes, which did reflect a lot more of the 95th percentile. A lot of those workflows are taking 27 minutes or more to complete. So many teams, when we think about ways to improve this, many teams are still kind of continuing to bias towards speed rather than robust testing. So the number one important kind of thing you need to be looking at when you want to improve this performance across all four of these metrics is enhancing your test suites with more robust test coverage. So that's, you know, there's a number of things here. I'd say one of the biggest things on this is like code coverage and the pipelines identifying any of those inadequate testing spots that you can help alleviate some of the potential challenges from pushing fixes that weren't adequately tested. So, you know, balancing workflow and, you know, test coverage that prioritization is gonna have to take center stage. So, you know, that means asking, you know, which of these features are really, you know, part of that critical path that we need to make sure that we're putting in? Where can you afford more, you know, experimentation, maybe on different pipelines?  It's okay to have a longer workflow than 10 minutes if you're getting good quality testing feedback. It's also important to know that like when you think about like duration for builds, it's gonna depend on what you're building. It might take longer if you're having to compile something, it's a big application, you're having to compile it as opposed to you're just kind of pushing some website changes. So understanding kind of what your builds are and setting your metric accordingly. So yeah, so teams that are focusing only on speed, they're not only gonna spend more time kind of rolling back all of those broken updates and debugging in production, but they're also gonna face kind of this greater risk to their org's reputation and stability. So optimizing those workflow durations means you're really combining all of these good test practices with efficient workflow and you all get to dance together. All right, so meantime to resolve. This is a metric, it's indicative of your team's resilience and your ability to respond quickly, effectively to feedback from your CI system. So it means it really is that best indicator of how mature your org's DevOps kind of adoption is. It's a really quick way to see that. You know, the way that users in most organizations kind of see this is nothing's more important than your team's ability to recover from a broken build. So customers are definitely more likely to, they're definitely more unlikely to notice any of those kind of incremental small changes that steady stream that kind of happens maybe throughout the week, but they're definitely gonna notice when they can't access the website or access that application. So that keeping the meantime to resolve, keeping those errors from the system is any recovering from broken builds is extremely important. Martin Fowler kind of talked about this, the quickest way is just to get back to the last known green build to start with and then you can adjust from there. And the whole point of working with continuous integration and ultimately that helps deliver that continuous deployment continuous delivery mindset is you're always developing on the lat a known stable base. So getting back to that green build is extremely important there. It is recommended aiming to fix broken builds on any branch in under 60 minutes. It's kind of what the data shows is what that high performing teams look like. So depending on the scale of like that user base that you have and how critical that application is, your target may be significantly lower or higher, but this is kind of that sweet spot of what it looks like for a high performing team to be in that spot.  So when looking at the data from the report, it showed that 50% recovery was kind of happening in 64 minutes or less, which was an improvement from previous reports, which was about 10 minutes longer. The top 25% was in less than 15 minutes and 50% of them, or I guess the top five, fastest five was in less than five minutes. So that's typically you're seeing that with smaller, obviously smaller builds, but probably less feature driven applications. So the first kind of step to lowering your recovery time is to treat like the default branch as the lifeblood of your project. It has that kind of main chalice of what everything should be. So your organization is gonna make sure that, while red builds are inevitable, getting your code back to green is always gonna be immediately important and it should be everyone in the organization's top priority. A vigilant culture that you kind of have in place where everybody is poised to leverage, getting back to that green build is gonna provide your best chance of hitting those metrics and reducing the impact on your customers. Recovery speed itself is completely bound with pipeline duration. So the shortest possible time to recovery is going to be the length of your next pipeline run. So if your builds, your duration and you've identified that your acceptable duration maybe isn't six, maybe isn't 10 minutes, maybe it's 15, well your mean time to resolve can't be any less than 15 minutes because the build has to run again so you're never gonna hit that metric. So it's an understanding how that fits together. So along with mean time to resolve success rate is that other kind of indicator of stability within your application development processes. But the impact of your success rate on your customers and developers is really kind of very according to a couple of different factors. One of those is like was the failure on a default or dev branch? Did the workflow involve a deployment which there could be an error in the deployment not really the build? Or how important is that app or service? So that's gonna influence how important in what your success rate when you set your metric is gonna look like. The failed signal isn't necessarily indicative of something that's gone wrong as well or a problem that has to be addressed right now. Far more important though is like your team's ability to take that signal in quickly which comes from that duration metric and then remediate that error effectively which is that mean time to resolve metric. Failed workflows that are delivering fast valuable signals are gonna be far more important than having a passing workflow in the high success rates that have little to no actual information, actionable data for development teams. Maintaining the success rate benchmark of 90% or more on your default branches is a reasonable kind of target that was seen through the report and in previous reports of mainline code of kind of a mission critical application where your changes should be merged only after passing a series of well-defined tests. Keep mentioning tests. It's really important for software development. Topic branch failures are generally less disruptive than those that occur on a default branch so if your development teams are doing a lot of innovative work and they're doing it on dev and kind of topic branches which is where that should be happening your success rate there is gonna matter less because that's where you're testing things or you're trying things out. So having a metric on that you have to hit a certain success rate on your dev branches is not as important as actually having it on your production kind of mainline branch. So looking at the data, the success rate on the default branch was 77% on average with 67% on the non-default branches. The trends over the report data kind of showed that success rates on those defaults have pretty much held steady and so a good standard is that that 90% we're still kind of coming in underneath that but we have seen like the pattern of the non-default branches, the success rate there starting to get higher and so we're starting to see that teams are starting to do a lot more test testing on default branches and doing a lot more development there and less on the production branches which is what you want to see. So throughput is kind of that last metric and traditionally that kind of reflects the number of changes that your developers are making in a 24 hour period. It's useful as a measurement of team flow as it really is tracking how many kind of units of work are moving through your pipelines but when you're performing at or around kind of recommended levels throughput really kind of puts that continuous in what continuous delivery looks like because the higher your throughput the more frequently you're performing work on your application and getting it out ready to be deployed. Of course it also doesn't tell you pretty much anything about the quality of your work that you're performing because it really is important to kind of consider how rich again your test data is and as well as how your performance on those other metrics like success rates and duration to really get that complete picture of how well your teams are performing because as with duration a high throughput score means little if you're frequently deploying broken code. So an ideal kind of throughput benchmark really is it depends. Typical DevOps answer I know but it really is going to be subjective to your organization goals. If you're a large cloud native organization that is deploying a really critical product line you're going to want a far higher levels of throughput than a small team that's managing kind of legacy software or a new startup that's working on a new thing.  You're not the Amazons that, what is it? I think thousands, tens of thousands of times they're deploying a day like that's just you're not gonna need that. So it really is going to depend on your organization and how you set those type of work, the resources, all of that. So in the data the kind of the median workflow ran about 1.54 times a day but the top 5% was running seven times per day. So when we look at some of the previous reports and I'll have it aggregated data to kind of show that here in a second but there wasn't much change from the previous reports there. Overall the average project had 2.93 reports that were run, I'm sorry pipeline runs in 2023 which was a little bit more than 2022 but while it wasn't much when you look at the sharp decline in meantime to resolve it is reflecting teams are committing to smaller more frequent changes to limit a lot of the impact that is had to the organization and to the customer as well. All right and throughput is really like it is the most dependent on the other metrics from any of the others that we kind of talked about. How long your workflows take to complete. If you're doing something that's gonna take you, it maybe takes an hour to compile your build which if that's the case then that's your metric. You can't do 30 deployments in a day, just statistically not possible. So understanding what that benchmark is for your org is gonna be extremely important when you look at all these metrics first. So improving that teams throughput, you really have to first address all of those other underlying things before you can get to how successful you're getting on your deployments. It is also a trailing indicator of a lot of the other changes you have within your processes and environment. So rather than setting just some arbitrary, pick a number out of a hat, you really gotta have something that reflects your business goals, your needs, capture that baseline across all of these metrics to understand how you're currently performing and then make the necessary adjustments. Achieving that right level of throughput really means staying ahead of a lot of the customer needs as well. So really understanding your customer and have a good feel for your product. All right, so when we look at all the data, you can kind of see these metrics over the last few years, see where some of the change is and when you measure and then optimize these metrics, your teams and your company are gonna gain kind of a really tremendous advantage over organizations that don't which can really set you apart and have that high performing engineering team that you really, everybody really wants to have right now. So you can get the report. This is a link you can go out, either QR code it or type it in there at the bottom and you can kind of get the report. You don't have to sign up for anything, just hit the download button that CircleCI has out there and definitely recommend. I'm gonna post these slides as well so that you'll be able to come back and reference them. Okay, so thank you, appreciate it. And I'm gonna be around the real rest of the day and the next few days, so if you wanna talk, talk about what you're all doing or have some questions around some of these metrics, would be happy to chat with you. So, thank you.


OK, I think we'll get started with the next speaker. So I'd like to introduce Sergio and Patrick from Intel, who are going to give an introduction and overview on VPP. That's when I have Mike. Hello, everyone. My name is Sergio Gonzalez Monroy. I'm a network software engineer at Intel, and I work on VPP and DPDK projects. On the first half of this presentation, I will be talking about VPP. I'll give an overview and an example of how you can modify and create new nodes. For the second half, Patrick is going to talk about practical analysis of VPP on interarchitecture and some recommendations. So this will be the agenda. Like I said, I'll talk the high-level overview of how VPP works and the functionality and features that it provides. I'll give an example of how to modify and adding graph nodes, and in this case, it will be the work I did for VPP integrating crypto dev. It will be as a plugin, so we'll see all the stuff that you can do with plugins. I'll also talk about the performance and how VPP kind of scale, basically almost linearly, and a final summary. So VPP stands for Vector Packet Processor. As you probably all know, it's a project inside the FIDO Foundation, and there are other projects inside FIDO. It's been in development since 2002, open source since 2016, and it runs in commodity hardware. It's fast, scalable, and consistent. It can do up to 40 million packets per second per core, no packet loss, and it has a scalable and hierarchical FIB, which provide great performance and update. It's also optimized for this commodity hardware, so it can take advantage of TPDK for IO, now also ODP. It can take advantage of vector instruction, depending on the platform you're running, so from SSC, AVX, AVX2, or Neon in ARM. And it's also optimized for instruction per cycle. So at the end of the day, it's all about performance. It runs in a multicore platform, and it takes the main concept will be batching packets and being cache and memory efficient. So it runs in a run-to-completion model, whereas every core runs like a copy of this graph node that VPP is. We avoid context switch. It's all running in user space, so there is no mode switching, and there is no blocking. Everything is lockless on the data path. As you can see, it's extensible and flexible design. So the whole idea is implemented as a direct graph node. That, as you can imagine, it allows you to create new nodes, reconfigure the whole graph node as you need. And it provides also an easy mechanism as a plugin. So you don't need to directly modify the VPP sources. It provides you a mechanism to add your own nodes and to put them into the overall VPP graph node. It provides control plane CLI, and it's very developer-friendly. So for those developing applications at this level, I found that it was invaluable. It provides packet tracing so you can see the packet going through all the nodes at any time. Every node can provide different information for that packet. It provides error counters, cycle counters, so you can see the average number of cycles spent per packet on every node. So it's very easy to identify it. So if one of the nodes or the node that you are implementing has a very high cost on the whole packet for that traffic workload. It's running like I mentioned before. It's running in user space, and it can be used with a common developer and two chains, just GCC or CLI. It's a full feature implementation. So we have full L2, L3 implementation, also now L4 with TCP and UDP. It provides CLI, basic IB2, and it's integrated in different ways. So as I mentioned in the previous presentation, so there is a netcoff junk for ODL. We have a Python API for Kubernetes Flannel and different language bindings like Java or Python. I think now also there is a REST agent for Neutron on OpenStack. And we have OSB packaging from different vendors such as Ubuntu and Red Hat. So how does this work? So the most relevant, we have two most relevant type of nodes, right? Internal nodes and input nodes. The input nodes will be those nodes that inject packets into these graph nodes, which usually are going to be your, can be IO. If that's a DPDK input, in the case of DPDK input, it will be direct IO from interfaces we are next. It could be AF packet input, or it could be from any other offload or FPGA or NIC that you may have. So once we get a bunch of packets from one of those graph nodes, we move them through the graph node in vectors. A vector basically is just a collection of packets, a bunch of packets that we're reading at any given time. Once we get them from the input nodes, like I mentioned, depending on the packets that we have, they will get classified and they will go to different nodes. So if we have Ethernet inputs that they are not IP, they will go to the Ethernet input node. But if from the input node we have a flag identifying the packet as an IP packet, it will go directly to the IP node. So we are saving cycles that way. So it can take advantage of the different functionality that your NIC will have and leverage that offloading and capabilities. Once all the vector packet is flushed out, right? So this, like I said, it goes through packets. So if we get, let's say, 200 packets, we work on those 200 packets until they have been out of the graph. That could be because we're dropping the packets or because we're doing TX on one of the output interfaces. So it's optimized for cache and memory efficient, as I mentioned before. The idea here is that each node will fit in the instruction cache.  So it will be in the instruction cache. You wouldn't have an instruction cache miss. And you would then use prefetching to get the packets and execute that functionality on the node, then move to the next node or multiple nodes. So I mentioned before the input nodes and the internal nodes. So here, in green one would be the input nodes and in blue would be internal nodes. The way that you configure each node, each node needs to know what are the next possible nodes. So you don't know where the packets come from or from which node packets come from, but you need to know the packets that they are going to. The plug-in mechanism is very easy, and they are first-class citizens. So even if you are a plug-in, you can add APIs, you can add CLI commands, you can add new nodes, and you can rearrange the graph in a different way. So you don't need to modify VPP itself. You can do it as a plug-in. In this case, also, DPDK is implemented as a plug-in. So we can create input nodes as a plug-in or other internal nodes. So now I'll go through the example. So this is the work I did for integrating the crypto-dev DPDK API, which basically is a crypto API for the IPsec implementation that VPP already had. So the idea here will be to modify the DPDK plug-in itself. We will create new nodes, and we will rearrange the graph to take advantage of those nodes. So initially, this will be the default path that you will take without other encapsulation for normal IP packets that are going to get encrypted. We will get a vector of packets from the DPDK input node. The next, because the NIC likely will recognize that there were IP packets, it will go directly into the IP4 input node, node checks. So in that node, basically, there is a bit of IP before header sanity and TTL decrement. So then we go to the FIB. The FIB will say, OK, this packet needs to be encrypted. So we will go to a virtual interface, a virtual IPsec interface, which is the IPsec IFE output. Once we go there, basically, we're going to say, OK, we need to encapsulate this packet with ESP and encrypt it. That will happen by default on VPP with OpenSSL. And once we have a new tunnel IP header, we go back to the FIB to find out what is the output interface, what is the new L2 that we need to rewrite, and out to the TX packet. So we modified the DPDK plugin to provide new nodes. Those new nodes were the DPDK crypto input, which is another input node that will be pulling from the crypto devices that DPDK exposed. We have a DPDK ESP and encrypt, because we do the encapsulation slightly different, and then we enqueue those packets down to DPDK. And another DPDK ESP and encrypt pass, which basically just gets some metadata. So the moment that we create those nodes and the plugin gets registered, as you can see, there is no connection from the IPsec interface output to that new node. So those nodes are registered. They are there, but there won't be packets being routed towards. That decision will happen later. So we can do that on runtime. On runtime, there are APIs that provide us to check, OK, do we have crypto devices? Yes. Then we can reconfigure the node on runtime to take advantage of those. If VPP doesn't find any crypto devices, it could use the default open SESL implementation that it already provides. So as you can see, the plugin is very powerful, and it allows you to do basically whatever and adapt to different platforms and function ID that you may have. So this is VPP performance data. So it's from the CCID project, which is another FIDA project that continues system integration and testing. And it's basically showing the scaling of VPP. In the left side, we have 1 million entries for IPv4. And on the right side, it's IPv6, half a million entries. As you can see, the scaling of interfaces and cores is almost linear. And you can see that the limit here is the bandwidth of the NICs and the PCI, and not VPP or the cores. So this is running on a dual socket system, Intel processor E5 with 256 gigabytes of memory, and 6 Intel XL710, which is a dual port for the Ging Nick. So as a summary, I think the main thing to remember is VPP is fast, it's scalable, and it's very flexible. It's developer-friendly. It has full feature, L2L3 implementations, also now L4 implementation with TCP and UDP. It's easy to integrate for your own necessity and to modify. You can have your own node, or you can work upstream, and it has a great community very involved. So that will be for me. If there are any questions, I'll take them later. And I'll let Patrick first get with the second half of the presentation. Thank you. At least USB is also needed. Hello, everyone. Thanks for coming here today. So my name is Patrick Liu, and I'm from Intel's network platform group based in Arizona. So just a very brief background about our team and myself. So we are the performance analysis team, very focused on IO performance analysis for the past 15 years. So I'm myself in the team for almost seven years now. So we have a very deep understanding of PCIe architecture, like we use in protocol analyzer to look at every packet. But throughout the time, we also develop various methodology, like using hardware counter or software technique to gather this kind of IO measurement inside. So today I'm going to share with you a couple of practical tools, as well as techniques for identifying IO bottlenecks, as well as on the CPU side, on the core side. If anything that goes wrong, how do we spot it? And then a couple of tips on how to improve performance. So the presentation is going to break into two parts. It's on core and core. And I know very now every one of you are familiar with this terminology. So I'll have a graphic representation in the next slide. But basically, I want to show you how to measure PCIe bandwidth, memory bandwidth using a set of hardware counters. And of course, the open source tool or how to get to it is nothing proprietary. Also on the CPU side, if there's an IPC instruction per cycle, it's a common matrix. But a couple of things maybe for the people new are Intel architecture may not be aware. And also, some other things to help dive into deeper into IPC. So this is kind of a diagram of a modern Intel Xeon server CPU. So I break it up basically in two parts. There's a yellow part for the CPU, the core side, which is comprised of an execution unit, layer one, layer two. And there can be multiple cores that run independently and then simultaneously. And the blue part is basically where on core. This means everything not core, we call on core. So like a modern CPU, surprisingly, the core is actually the efficient part of it. So the main real estate was the last level cache. So it can be up to 55 megabyte on the fourth generation or memory controller, IO, all this kind of peripheral. But the peripheral today, especially in our domain, the network processing is really actually the key for interacting with the world. So we need to have good tools to get more visibility into our core space. And then the purpose of this slide is not to go through all the bullet points, although you're certainly welcome to visit this because this show very complex of interaction between CPU and IO for basically life cycle of a packet, how it go into a general purpose CPU. But really, the takeaway here is I want to highlight the traditional, our performance methodology is very core-centric. That means we look at IPC, we look at branch prediction ray, we look at TLB or hit and miss, those kind of things, very from CPU perspective. But with our workloads, IO very century, we need to have a new ways or new methodology to look at IO century workloads. So yeah, let's jump into the practical thing. So today for my main tools, I'm going to mention for processor counter monitoring or PCM, it's a tool I call develop with other Intel software developer. It's open source now in GitHub. Basically, it has a very lightweight of, it's set of lightweight user space tool that program our hardware performance counter, but they display in a very high level abstracted. So it has a formula to convert. So you can, for example, just from a glance of you see memory bandwidth or various level of cache miss ratio. So you don't have to do all those converging by yourself. Also, it will have like a C or C++ API if you want to do like a next level integration into your workload to get a more fine region by region kind of performance inside. It has API allow you to do that. And it's a BSD licensed. So I understand that all of the deploy environment can install or deploy custom tools, but Linux Perf is probably pretty ubiquitous. So in the backup slide here, I will provide like a simple command line so you can do a similar profiling with up to date kernel means for that all plus with a set of wrapper so you can accomplish the similar thing with Linux Perf utility. So just a brief words about PCIe. So ever since our first generation E5 processor, we had introduced technological data direct IO, DD IO. So maybe many of you already have a first-hand experience with it, but it's basically whenever you have IO, DMA, read or write transactions or your network receive transmit, instead of going into memory directly, it now will go straight into last level cache. So the advantage is in two-fold. So if CPU can consume the packet directly, your latency is much quicker, at least twice the saving compared to going out to the memory. A second, if that is indeed a case, your memory controller could be practically keep at most idle. So if you idle, the memory controller can like a power down or run at a lower frequency so you can save platform level power. But there's some condition where the packet right into last level cache will still eventually get evicted to the memory and then I'll show you how to catch that and what are the ways to avoid it. So, yeah, to kind of major PCIe bandwidth, it's pretty simple to get started. So you just download the tool and then run the Mac commands and then invoke PCM PCIe. And there's some cryptic name here, but so I kind of highlight in the four-point takeaway. Let me just get a little later. Yeah, so the first thing is, oh, by the way, because of the time constraint, I probably couldn't go into the lowest level detail today, but we are going to have a white paper coming out, explain all this in much greater detail and a search right now, we are also available after the talk. So if there's a deep question I didn't cover, we can certainly grab a whiteboard after that. So four-point takeaway is you can look in at the right event to measure your inbound right. So this is your network receive, whether you have a full cache line or it's a null cache line, that's like a null 64 by a line, it's called read for ownership, it's inbound right. And then there's also the transmit path. So you want to send the packet out to the network interface to the wire that will trigger the PCI recur events. And MMIO here is basically your outbound operation. CPU wants to address like either reading the status from the device, a PCI device, or want to notify the device to start initiate asynchronous DMA operation for like a receive or transmit. So what you want to kind of do with once you know what you can measure, what you basically want to do is want to match your IO throughput for whatever you expected with this reliable hardware counter because as you get more experience to develop like a packet processing on general processor, you may not need to do this as often, but initially like I have, we have seen couple of cases from customer where they forget to include in, they were using like a storage device, PCI NVME to store data coming from the wire or they're using hardware crypto accelerator. So they didn't consider that part also using PCI bandwidth, equivalent of PCI bandwidth. So you are hitting basically PCI bandwidth limit. So it's like really 1.5X or sometimes 2X on the wire for every packet coming into a system. So it's good idea to just calibrate your IO bandwidth, your workload, make sure there's no surprise, right. And then come to the MMRI, it seems DPDK, I think this concept is kind of well understood, but to just batch your MMRI operation because you want to save those available PCI bandwidth more for the receive transmit function, not just this kind of doorbell signaling steps, right. And the orange part is like a what you want to avoid. Unfortunately I don't have time to go to the great detail, but this one is absolutely I want to call out because MMRI, I don't know about other architecture, but on Intel architecture it's very long latency operation, right. It can easily take up to 200 cycle for each single read. And there's very little technique you can hide those kind of long latency, like pipeline, auto order, it doesn't work with MMRI. So avoid MMRI at all costs, right. Okay, so come into a major memory bandwidth it's as easy as the PCM, PCIe, just compile and run PCM memory. So what I want to highlight here is a typical like a fully loaded two socket configuration, right. There's a three main component here. You have a CPU, you have the memory and you have the IO devices. So all three of them have to be aligned on the same socket. If not, they can introduce some memory traffic and not only that, they can introduce latency, right. So when you see memory traffic in the system, if you know it's best, but when you do see these are the kind of three common reasons you do see them. If you have a wrongly allocated NUMA for any of the three component, then try to fix it in the code or isolate it, right. So, and if you have a DDIO miss, that means the packet, every packet is coming into last level cache, but if they don't get consumed by the code fast enough, then the new one come will evict the old one out to the memory. So means try to process or move this packet as fast as you can. And the second thing I highlight here, although I talk to Sergio was, it's not universally applicable, but it's one of the tuning techniques to basically sizing your descriptor ring size. So like you can be typically 1K for RX descriptor or similar for up to 4K, right. So the bigger you size your descriptor ring, you can absorb more packet and probably avoid packet loss, right. But on the contrast when you have a larger descriptor ring size, you're basically giving the chance you have more packet buffer in a system and more system, more packet buffer in a system can have a more likelihood of causing collision. So size that descriptor ring appropriately, like don't just say 4K, it's good for every test case. It may be okay for 20 gig, 40 gig, but if you scale to 100 gig, 140, 160 gig, you may have to look at system level and then reduce the descriptor ring size per device accordingly. Finally, it's actually the most common way you see memory traffic was where you have a hash or your lookup table, depending on the size of it and then how well they can be cached into your local level cache. If it's very big, there's a highly likelihood you will get it from the memory, right. But if they are streaming, means they are all coming in in a pipeline fashion, you might be okay, but if not, then it can occur latency impact your performance. So a check for latency. So yeah, kind of the takeaway here from the kind of on-call side was the first and also it's found the easiest to the most advanced to address it was to calibrate your IO bandwidth with your expected performance with this hardware counter available to you, right. And also check for unexpected cross-NUMA traffic, like if you have only single circuit system and you will never run into this issue, but if you are scaling, now run your same workflow on just the second CPU plug-in, if you don't have this NUMA API to allocate right kind of things, you suddenly will see performance drop where you don't know where it from, just look at memory bandwidth. And avoid MMIO read, as I said, long latency instruction, batch MMIO write, and hopefully we can see each other another time to say how we can optimize software to best use of DDIO. It's a very kind of advanced topic. Okay, so moving into the core side, I kind of prepared this interesting tool, very big number here for the audience to take a quick look. So this is basically a VPP 17.04 running two different configurations. And then first, using Perf, give me IPC number of 2.63. The second one, give me 2.12. So which one do you think has the highest throughput per core, right? It's generally IPC, the higher the better, right? And then it is kind of say, you have higher IPC, you have a higher throughput. So the reality is, so what I hear actually is, the A was that kind of prior to 17.01, we don't have a crypto dev. It's just an optimized VPP IPsec using OpenSSL versus the B is using AESNI crypto dev Accelerate. Despite our IPC slightly come down, IPC is really just a ratio between instruction divided by cycles, right? But surprisingly to me also, the traditional one is probably very, there's a lot of layers of processing to do to accomplish the similar functionality. It takes an average of more than 15,000 instructions per packet to get the IPsec encryption to accomplish its job. So even though the IPC is tuned, it's very like a well-designed dual loop and prefetching this kind of technique to make IPC very smooth, simply because the amount of a call has to be applied for every IPsec packet. It just causing huge number of a cycle per packet, right? Whereas in the crypto dev, we also introduce more direct path to accomplish the same IPsec way. We only have to do 1800 instruction per packet in average and that in turn, reduce our cycles per packet by six times and that's your speed up in performance. So kind of the takeaway is IPC is really just a ratio. So unless it is really poor, like a less than one or something that can indicate really big, bigger issue. But if anything is closer to two or above two, we look at instruction per packet or cycle per packet. That will be a better core matrix for comparing performance. And that's also nice cycle per packet if you change into different skill with different frequency. It's still kind of you can scale it appropriately. So beyond IPC, how can we zoom in to more to understand where it's a CPU bottleneck, right? So this is where I want to spend a few minutes talk about processor trace. It's basically a new hardware since fourth generation processor, but it's also applicable in our Denver atom-based microserver, so it's pretty good. Like you can use it on different class of machines. But you can think of it's basically a hardware that's like a branch tracer. So without any kind of condition if statement for loop or anything, it will basically, the CPU is just going to fetch next instruction, next instruction execute forever. But whenever you have if condition is based on the runtime condition, right? Your packet size, your packet header, content orders decide where you go. So this is a branch tracer can reveal this kind of exact execution path of how your program was executed. So this is a dynamic tracing technique. You can like, you have analyzer in your CPU free one. Okay, so there's also just a couple words mentioned in the integration with like ubiquitous Linux perf tools, right? And a button here you kind of see this is a flame graph of various transition for different function that is doing complex processing. But really the takeaway here is the Linux perf with like a modern kernel 4.4, like Ubuntu 16.04 or newer, then it has like out-of-box support for this hardware support. So it can give you like a finest detail like how your code was executed, but you need to do some post-processing to reduce the tracing data because even for one millisecond of trace, it give you like maybe more than 20 million instruction. That's like maybe thousands of loop iteration of your packet processing, right? So reduce that is kind of data analytic subject too. So here it's just kind of another like interesting demonstration of processor trace applying to VPP how we can get more insight for performance optimizations, right? So this chart you can think of it's like a VPP trace, so you see like when packet was coming for receiving and then doing various nodes processing and transmit out, but even finer granularity. So I abstract it out here to show the key component but you can really trace into instruction granularity what happened to your packets, right? So the first thing to call out here was we have a vector with 256 packets and for people that understood DPDK we have every receive is 32 packets so if one together that many packets in the vector we have to call it 8 times 8 times 32 256. So you can see if your CPU is fully loaded or like the amount of traffic coming out at bursty or they are very scattered. Similar thing transmit out we receive 256 we want to send 256 out. TX we are bursting at 16 so you call it 16 times to get to that vectors. And then here you can also see where are the most densest function in your code. So VPP provides psychopanel but here basically provides you how many instruction panels you are doing. So because instruction is kind of what a programmer write write C code that generates assembly instruction and then psychopacad is kind of the amount of time to execute in this work. So with this amount of detail information you can kind of see where you need to spend your effort for the next level optimization, right? Or if hardware or flow come to the picture this can also tell you where you may need to consider hardware or flow if really we exhausted all the software options. And then another final thing to call out was actually this was unexpected but throughout the preparation of this presentation we found out the typical way of launching VPP did not use the most optimal or actually I should say the most minimum receive path because the initialization parameter passing from VPP to DPDK was 9K for the max package size so DPDK just choose to use scatter as a receiving path, right? So this kind of thing is good to call out that you may not notice at the compilation time or development time but when you're really doing the benchmarking here we'll show you what functions are called at runtime. Okay, so really kind of to summarize everything that we quickly gone through today was to using your available performance monitoring hardware to baseline your workload performance, right? There's a rich set of tool available Open Source Live for you, PCM or Linux Perf and then really to improve performance is two main factor, right? Whether we can reduce instruction come per packet by creating more VPP direct VPP path to processing packet the IPC slide was a great example how a very structured way can take a very long instruction per packet but if you understood what your end goal is maybe we can take a more shortcut like implement plug-in to process that directly also consider hardware off-load whenever you're exhausted, optimization from a software perspective, right? So reduce cycles per packet is kind of... Yeah, the meaning is very clear but to do it you can kind of go through the uncalled performance take-away side to minimize your latency as much as possible and then one thing we did not cover here today but it's kind of good to keep in mind was the CPU L1 miss latency if we measure those we can kind of get the residency view like basically your data structure are mostly cache in L2 or in LLC or memory so that will give us indication which hash table we have to optimize and then there's a lot of reference for you to download a tool or documentations Yeah, thank you Oh, Lisa, sorry, right? So what time is it? I'm here for Patrick Hi, thank you for the presentation My question will be in the sense of virtualization using VMs and containers leveraging what you have presented Do you have any performance benchmarking that you have run using containers and VMs leveraging the user space flow graphs as well as your optimized host configuration? Thank you I think the data that we have presented was all run at least the one from the CCD graph on scaling VPP was on the host so there was no virtualization and containers I think that if you look into the CCD project there might be some use cases for containers usually containers at the moment we are not doing the SIV path at the moment so it will be with AF packet or V host VTO but I think there may be some performance information there I don't know of the top of my head Okay, I think that's it then Thank you