Today, I'm going to demonstrate to you how to detect fraudulent transaction in a financial institution. This demonstration will portray Red Hat OpenShift data science project which helps data scientists to seamlessly train their model and not not figuring out the overhead of setting up a cluster and all the tools associated with it. I would be using TensorFlow and I would also be using product called Starburst which internally uses Trino and there will be briefly Open Vino is used in this but Open Vino is more under the hood of Red Hat OpenShift data science model mesh, it's under, model mesh uses Open Vino model server.  So to do that, what we would do, let's say we have a data set. I picked up a data set from online. I will share the resources later from where I picked up and that data set has some, we need to do some pre-processing. So we will do some pre-processing and this is the area where Starburst will help us or at least Starburst has many other features but this is the place where I'm going to use Starburst for and then I'm going to use TensorFlow to train my data set to a model and after that, I'm going to serve that model using OVMS, Open Vino model server, which erodes model mesh users as a backend internally. So now the user, when I have this model served over here, the user can send a rest request and can receive a reply. It gets a reply with it is for a fraud or not. So just some brief interaction about what roads is, but there will be links for more, if you want to learn more about roads, Starburst or Open Vino. Red Hat OpenShift Data Science is a managed cloud service for data scientists and developers. It provides a fully supported environment in which to rapidly develop, train and test machine learning models in a public cloud before deploying in production. Starburst is a fast and scalable SQL engine architected for separation of storage and compute. Starburst Enterprise is cloud native and can query data in S3 Hadoop. Basically, Starburst can have multiple data sources displayed to you in one dashboard. Open Vino is an internal toolkit. We would be using that briefly. They provide a kernel. They also provide a model server using which we will be serving our model. That said, this is the section where my Starburst query editor or Starburst functionality will come into play in my demonstration. This is where Open Vino would be used internally. Let's see all of this in action. This is the GitHub repository which has all the code which is needed. It has all the instructions and everything. You might be here from Sandbox or Red Hat Demo Platform, RHDP. Or you have your own OSD cluster or something or your ROSA cluster or something in which of course the prerequisite is you will have a row which is the backbone for this demo. Just try to open this on one side like this. As far as our repository, first we need to create our data science project. The way to do that is we will go to our dashboard, Red Hat ODS dashboard. Here it will come to the data science projects place. It will create a data science project. It will name this. It will add a workbench. The notebook image we are going to select is a tensorflow because that's what we are going to use. Basically this will install all the tensorflow packages for us in our Jupyter Hub notebook which Rhodes uses in the backend. Rhodes is an accumulation of multiple individual softwares if you may think it in that way. We will give that a name and we will create this. We will give it a few minutes or maybe one minute for this to start up. That's when I will have my Jupyter Hub notebook ready. If we hover over here, we can see what this guy is doing. You can see the event logs if you want. Like it's pulling the notebook image and stuff like that. And then voila, it's there. So now our notebook image is pulled and we are ready to access our Jupyter Hub notebook. So when I click on this, I will not see this permission thing because I have already logged into this a couple of times. So it's the RBAC policy you may see. You will just see it for the first time. So when it's logged in, what does it say? We are here now it's asking us to clone this repository. So we'll come over here and clone this repository. At this point, pretty much it's asking us to double click on our repository and notebook. So we can ditch this read me file because we will have all of that in our Jupyter Hub notebook. So close this window, open this guy in a bigger format or full screen. Yeah, full screen, good. Now we'll start by installing some dependencies which we need for our project. Then while that is happening, I'll paste on this cell. I need my AWS access key and secret key. So I'll paste that. I'll blur this area in the video later. Next, that's done. The second is done. So this cell over here, this helps us to visualize. We will visualize few graphs later in our notebook. So this will actually makes the graph look pretty. So run that. After running that it's saying use Starburst Enterprise platform to visualize and clean your data. Okay, so we go to this guide. This guide has some requirements, but basically we have our original data set which has some empty values. It's a CSV file, which is our data set. It has like around 280,000 entries in it. It may have some empty values. Not me, it will have some empty values. We need to update that to our S3. Depending on how you came to this video, you probably already have this set up for you or you might be bringing your own S3. In that case, you will be following this instructions. And then you also have to configure Starburst. But in this video, again, we're depending on the source from where you're coming. The Starburst might already be configured. Starburst needs a license. So that might already be configured. I have already gone ahead and configured all of this, which is to say, uploaded my video, sorry, not my video, but my CSV file to my S3 bucket, which is over here. In this folder called data, which has my values. And I've also configured Starburst. So if you see at the end of this configuration, there is something called Starburst provides UI, which I have a route here. And all of that information is actually inside this. Then you have a file to create a license to create AWS credentials and the secret. And then the Starburst enterprise CRD, this Starburst Hive CRD, or CR, not BCR, and also the route, which will help us route or route. I don't know how you pronounce, but so, so which is all done here. And now when I clicked on the link, clicked on my route link, it got us here. You can give any name. This is use admin. When you have the Starburst enterprise license, you get this query editor. Nice looking query editor, which can help us with this is one of the features, which can help us, you know, seamlessly use Starburst. So what I'm going to do at this point is take this out and split the screen, half and half, so that we know what to do here. Okay, so, so first thing first, it's asking us to create a schema step one. So we'll copy that. We will paste it here. And this is a different bucket. I'm trying to do my own bucket, which is this guy. Yes, that's right. So this will create a schema for me with the name fraud. So that created a schema. And if we refresh this file viewer or data source viewer, you can see that the new schemas here. So one fun thing which I love to do is use this S3 here and then a schema. Now, in that way, what happens is here on when I run the command, I won't have to specifically say, okay, I want to go to the S3 data source and I want to go to the fraud schema. I can just directly say the table name and stuff like that. So that's, I find that useful. So let's see to continue with our example. The second thing is we will try to connect our, our data set, which is here in our S3 to our starburst and the way to do that, to visualize the data to do that would be we will create a table named or we can remove this part here. You can keep it that manner. We will create a table named original and these are the fields. You know about these fields already. And we will use a with pause where we will see our external location is S3 that's the protocol to access S3 fraud detection DS data format CSV. This run successfully. We should see something called original. So there you go. So our data is already here. The next part is, so this guy is done is to visualize this data. So what we are going to do instead of copying the command from there, starburst already provides us like few most, I don't know, use commands for some of this click on that. I'll print it. I'll make this big here. Yeah, so there you can see we can visualize all the data. And you may see that like, for example, this guy here, we 13 column has an empty value on this row. So this is what we will be tackling next using starburst. But before we do that, I also want to copy this command. I can just do control C, go and enter paste. And I want to count how many, how many columns are sorry rows were there in the original data set before we do our stuff. So originally there is 284,800 something rows in this data set. We will now clean that data set, which is basically remove any column, which has any column which has empty, any row which is empty will remove that column. We will use this command over here. But before we do that, we'll actually use a trick, a trick to set a session variable. And you may ask, what is this? The curious mind may ask. So basically what happens is the way starburst works in the back end is you can have there's something called coordinator and there's something also called a worker. So the worker basically think of the worker as the one which does the heavy lifting in these queries and the coordinator as like the traffic guy. Like it directs what to do. So whenever I run this command, this command goes to goes to the coordinator and the coordinator uses us one of the compute or all of the computes depending on how many workers you have to do the actual heavy lifting there. But in the process, what happens is you may end up with multiple CSV file and that's okay to end up with multiple CSV file because that it parallely processes our data set. But we want one single data set as an output because that's how I wrote this. The Jupyter hub notebook which is this notebook is written in that way. So what we are going to do, we're going to first run this command and we'll see that it's something called writer min size which is 32 which basically anytime a data set goes beyond 32, the writer scale property kicks in which is enabled and it says okay well it's more than 32 the size of the data set so I should create another file and as long as till the time all of the data set is not processed. So I know my data set is roughly 160 MB. The way to get the trick or kind of like a hack to get around it is I know my data set is can max be 160 MB. So I will set this property to 160 MB and then if I run this again we will see that this is 160 MB. So in this case what happens is while one of the workers processing my data set it won't parallelize, parallelly try to process it because it's like oh well this data set is within 160 MB. So although writer scaling properties are enabled but I have not met the minimum threshold. So that's what it is here to get a single file in the end. So after this the next part is this is the way how we clean our data set and after cleaning the data set what we will do is we will save that in a new table called clean. I'll remove this part I don't need that because I have already set it over here. So I'll use clean as the table name and this will go to my pocket named fraud detection BS inside a folder called clean. Once I run this guy this thing is going to take like I think about a minute or 45 seconds. Meanwhile, yeah that's about it we can review while that guy is doing. You can review there's nothing more to do here now results are like we should go back to our S3 bucket and we'll see there's a folder called clean which has our new file something like this. So we'll go back to our original and we'll close this read me file. So this guy is finished and it also tells us how many rows it has written. So if you remember, initially we had 280,000 rows now there is 253,000 rows approximately. So the rest of them had some empty values so they were removed. So this in my case I'm considering this as my data set is finally cleaned. So let's anything else to do here now we'll just you can also check or no the schema. See the new table is updated here so that's all cool. So I'll lock this out now close this window zoom and make this window larger. Let's go to my S3 bucket. Let's refresh it and like it said over there I have a clean folder in my S3 bucket which has a CSV file doesn't have the extension.csv but it is a CSV file because we've set the format in our query as CSV file. So now we will go back to our notebook. Open this guy and we already posted our access keys and secret keys secret key. Now there's a small helper function over here which will help me to download that file the clean data set to my local directory over here. And once it's downloaded the reason we are downloading is then we will use that file from our local to perform our model our training process our training and testing process. So let's do that let's run this guy on goes well I should have a folder over here so it's already completed as you can see. I let me refresh and there you go I have this file here it is 142.6 MB great. Next part is I will use a pandas data frame read CSV file and I have used over here zero because I only have one file. Remember how we said that session variable earlier session variable I could never see that word nicely but that session variable let's see if you had not said that what would happen is you would have ended up with multiple CSV files here and basically here you would have had to loop through the whole folder. I didn't want to do that I wanted to keep it simple or maybe use a concatenate function or something I don't know but loop through and yeah but I wanted to keep it simple so I left it I used session variable as a hack. Let's describe our folders we can see the total number of rows like we saw in starburst UI editor there were 253,000 approximately rows. So if I have to explain this in this data set these columns in the beginning or all of these which you see. I think there are about 30 30 columns these will be our training features. If I am using the correct data science or machine learning word terminologies and this is the variable column which all of the all of these columns will help me to predict the class so the class is binary if it is if it's zero means no it's not fraud if it's one that means it's fraud. So so what we will do next is we will we will rename that class field or column to something called is fraud to make it more you know it would make more sense and we will also see the percentage of fraud in our whole data set so let's run that. So after doing this if I. Okay, so so we can see the percentage is 0.0017 that's like really small number. Of of fraud so this is something in this in data science world if I understand correctly it is called imbalanced. Data set and because therefore our next task would be to one of the next task would be to do the. Only only 0.17% is fraud which is like an imbalance so while a low percentage of credit card fraud is certainly good news for the credit card company but. The writer whom I am following. The blog in total towards data science is kind of funny. Is is good but it's not good for our model so we will use a technique called smoke. And we'll also look for some missing data but I don't will not find any missing data because there is none in this data set will see the correlation graph. The correlation graph. Gives us a all rounded understanding of the variables in. In in our. Data set. Yeah, the next part is will define the X and Y's. If I understand correctly X are the features and Y is the variable. Yeah, let's define those then we will use a use a standardization technique basically it's best practice for training neural networks to standardize the features. So that we have a good model will do the training and test split split. And this is the smoke technique I forget the full farm yes the full form of smoke is synthetic of minority over sampling technique in this what this will do is basically. Because of that low percentage of fraud which we saw earlier here which is 0.17%. This this smoke technique is basically going to balance it out so now you can see that equal amounts of so we have zero and one zero means no fraud and one means from this has balanced our data set. There is equal amounts of fraud and equal amounts of no fraud. The next part is I don't know how this legible. I'll try to zoom a little bit seems like it may not be very visible. Okay, good. I hope it's you can see well now. Okay, so here now. We will define our layers so we are using like we like I said we are using 30 input dimensions. And we have a couple of layers over here. And I think sigmoid is this is the one which is used for something finally like zero and one. Let's run that so that's our layers. And the next part is the training part. Okay, so this is the fun part. The training here we have 100 epochs and which will take some time to run 100 epochs here. What I will do is I will run this and pause the video. And come back when when it's done or maybe I will just do 10 even 10 takes time. But yeah, I'll pause the video and I'll come back when it's done. Okay, so now we can see that our 10 epochs are completed. But something to note here that we start with an accurate on epoch one we started with an accuracy of 0.21 and we had epoch 10. We ended with the accuracy of 57%. So with 10 epochs, that's all you're going to get. If you run it higher, best case best would be 100. You will see that your accuracy is improving a lot more. But this is just a test model. I'm just showing you how to run this when you're doing this at your leisure. You can probably run 100 but just it takes a little probably 20 minutes or so. Well, that again depends on how many workers and this and that how much resources your cluster has all of that. But yeah, it takes a while. Anyway, so after running some model is ready at this point. And we will now what we will do is we will we will run. We will save our TensorFlow model. That's what we are doing here. In a folder called TensorFlow PB models, because that's the format I think dot PB or something which it saves. And then you're going to use a binary called model optimizer. So if this binary is provided by open vinyl, this binary will take the TensorFlow model and convert it into open vinyl IR format so that we can run the model. Serve this model through open vinyl IR. So let's run this cell and see what I get. So we can see the assets are written over here. Let's refresh this so we can see here we have our saved model and the assets and everything. And then we have the model optimizer has also converted taken that model and converted into into the file into the supported format open vinyl IR format, which the open vinyl model server can read. Okay, so that's it. The next part is to upload my open vinyl IR formatted model to the to our S3 bucket. And there is a guide for that. But one thing to note here that depending on where you are again coming sandbox or RHDP or having your own cluster or what. The step one in this guy is kind of optional. I should mention that here is optional to download this and upload it optional in a way because I recently added this new cell over here because we already have the AWS credentials earlier here. We're going to make use of that and the session and we will upload our files, which is these two files over here to our S3 bucket. So let's actually first go ahead and run this so that our model is uploaded in S3 bucket. And that's done like that. So let's go to our S3 bucket and check if our model is uploaded. There you see, there you go. Our model is uploaded in the model folder. Great. Now, at this point, I'll go back to the guide. The guide is still useful. It's not like the guide is not useful. The guide is still useful. And I will tell you why the guide is useful. Because now that we have our model uploaded to S3, we need to do some more configuration in our data science project or in the ODS dashboard. And that is what the step two, sorry, the step one, we don't need to do step two. We don't need to do here because we have already uploaded step three. This is the part which we will be doing here. So basically we'll create a data connection, give it a name, something, something. Okay. I was looking to copy paste something, but then finally credit card S3. And again, we will use our credentials, have to blur this section. I need to remember to do that and paste that. And we'll leave everything else because my bucket is US East. So I'll leave the region to there. And my bucket name, yes, that's the important part. Copy that. I'll paste my bucket name here. And I will just create the connection. Does this new thing about connecting to my workbench? I need to. Is that needed? No, it doesn't seem like it's here. It's all right. Okay. So now my data connection is created. The next thing which we need to do over here is to deploy a server first. So this is just the properties of the server. It's just one instance. It's a small, I will definitely need to make this routable externally. So I'll click on that and I'll click configure. So there you go. It's pretty instant. My model server is there. I need to just now deploy a model in it in which that model will serve. So I'll scroll down. Oh, actually this chip shows me how to do it. Click the model. Oh, okay. This guy here. Then model server open window IR format. You can, if you have your model as ONNX, that's also supported. Existing data connection. Yes. We already created a data connection and we will give it a path. And the path would be models.model2. Actually, no, it will be model, path is model and inside model. Just, yeah, just, just model. Let's deploy that. We'll wait a little bit for this model to get deployed there. So our model is now deployed. Like it says, if I use the size of this guy, it's deployed loaded. So this guy also tells me to copy the inference link and go back to notebooks. I'll copy this inference link and I will go back to my notebook.  And here this guy is asking me to paste my inference link. The next task. So that's what I do. I have already pre-formatted a request, JSON request, which I'm going to send. Now, JSON data, which I'm going to send as a post request to my REST endpoint, which is on my inference link, which is this guy. So let's run that and see if that is a valid. Oh, okay. So good. So based on this, it is telling me that my output is actually, this is a fraud, because it says it's one, which means it's a fraud. Now, how effective our data, our model is, we pretty much know our model is probably 50% accurate at this point. 49.99% which is 50% accurate. So there's a high chance, 50% chance that this is wrong. But if we, yeah, but the purpose of this, this, this, this demonstration was not to, you know, have the perfect model, but more to how seamlessly you can do, which is Jupyter, all this different software products, which is like Jupyter notebook, TensorFlow libraries and other Python libraries and Starburst and data sources and connections. And so, so all of that, how it can help your productivity and how quickly you can stand up, you can focus on what data science can focus, data scientists can focus on is just doing creating good models and not on the overhead around it. I also have some few fun stuff, which I was playing around with. Yeah, so basically, yeah, let's let's let's run those guys. So I'm just taking the using data science people pretty much knows what it is. But I'm using the prediction where if it is, if it is more than because this value is here supposed to be in probability in a probability of 0 to 1 can 0.1, 0.2. So I'm saying that if it is more than 0.5, then it is fraud. And if it is less than 0.5, then it's not fraud. So that's what I did. Now, what I'm going to do is I'm, I'm also calculating the accuracy score here. The accuracy score here tells me that it's 99% accurate, but where till we get the F1 score. The F1 score tells us that it's not 91% accurate. And I honestly don't know a lot of different between this guy here and this guy here. Yeah, that is something I'm just not so data science literate, I guess. But I do know that the F1 score is different than the accuracy score. And this guy, the confusion matrix, this is, this is the thing which I like is tells us or tells me that. So, so what it tells me is the true label and the predicted label. So it's saying that the true label predicted non-fraud to be non-fraud 50,606 times. So that's great. But, but it predicted fraud to be non-fraud 22 times. That, that is probably a problem. You cannot predict a fraud to be non-fraud. So, so our model is not perfect. We see that here. The next is then the ways our model also predicts 25 of non-frauds to be fraud, which is okay because that is, it's a false positive, right? That non-frauds are treated as fraud. That's okay. You're not, it's not a problem in the financial world. But what is a problem is this 22 guy over here. And the other, other, other thing which we know is our model says 75 of the frauds as fraud. So that's good. Anyway, so that's all about this presentation. I hope you enjoyed it. And the, the, the GitHub repository has all the, all the details on things which I was setting up over here. Those details are there, things which I was not set in, which I didn't set up here. Those details are also there in the, in the GitHub repository. Yeah. Thank you. Thank you so much.


Hi everyone, Joe for Jaspy's casebreaks.com coming at you with the last filler for that basketball mixer where we're giving away that Michael Jordan. That's going to be in the next video. But in this video, we've got three different dice rolls happening here. First of all, we're going to give away six mosaic pack spots. Then the second dice roll will be the pack break itself and the third and final dice roll will be giving away those mixer spots. Big thanks to this group right here for making it happen. So there are the six spots that we're giving away. Let's gather everybody's names. Got a little buy one, get one situation potentially for you. Let's roll it and randomize it. Four and a one, five times top six after five. One, two, three, four, and fifth and final time. After five, we got Steven, Steven, Alan, Steve Birch, Jason, and Zach. Extra spots going your way. Little buy one, get one. For the rest of you, don't worry. You're still involved in the break. You're still involved in the potential mixer spot. But Zach, Jason, Steve, Alan, Steven, a little extra odds to help you out potentially in the third and final dice roll. Now let's do the pack break itself. Dice roll two, two and a four, six times. Names and teams. One, two, three, four, five, and six. Got Alan down to Adam. Two and a four, six times for the teams. One, two, three, four, five, and sixth and final time. Got the rockets down to the jazz. All right, so there's the first half of the list, right? There are no trade windows in these quick little pack fillers, filler breaks. Second half of the list right there. Let's just dive right into it. There's the final printout right there. And let's see what we got. We have DJ Augustine Red, Blue Chips, John Morant, Cam Reg in the back right there as well. John Morant going to see Birch from Memphis. All right, that's that. Let's flip back here really quick. Let's gather everybody's names for the third and final dice roll. So it's going to be the top five, not too many people, top five after three, two and one. One, two, and third and final time. So from six on down, Jared very close, no cigar, but I appreciate you trying. From six on down, it's sad times. But I appreciate you trying. Happy times, though. For the top five, you've made it to the next round. The basketball mixer, Michael, is happy. So it's Steve, Jesse, Stephen Flatt, and Alan. Congrats to you. We'll see you in the next video for the next break, jaspeyscasebreaks.com.


Hey everybody, it's Brett with Summit Auto and I'm at the 2022 Chicago Auto Show and today I'm checking out this 2021 Ford Mustang Premium and just want to do a quick video on this one. It's grabber yellow. It's been getting a lot of attention, a lot of people looking at it. Definitely an old-school color on here. It has the black appearance group as well and just wanted to give a quick walk around. Check out those rims. Check out the yellow. We'll take a look at the window sticker here in just a little bit. Nothing too special on the interior. It's just a premium so you're gonna get the leather interior probably heated and cooled seats. Yup. It has the automatic transmission. I think it's a 10 speed. It has the adaptive cruise control, normal cruise controls, blue tooth and all that. Memory, driver's seat, the auto headlamps, the big instrument cluster in there. None of the power's on so I can't really start it up anyways. It has blind spot monitoring. Notice you get the black grill or I'm sorry, the black backs to the mirrors.  It has Pirelli tires on it, four wheel disc brakes, blacked out headlight bezels and the blacked out Mustang on the front. Also the blacked out heat reducers. I don't think they're functional. I think those are just for show. Here's a look at the original window sticker. This one does have an MSRP of 38 510. As you can see 10 speed automatic is a $1,595 option, black accent package. It has the 201A group. It gives you the premium trim with accent grip, premium floor mats, Ford safe and smart package, adaptive cruise and voice touch navigation system. Once again 38 510. You're going to get 32 miles per hour or 32 miles per gallon on the highway. 21 city for an average of 25. This one does have the 310 horsepower 2.3 liter EcoBoost engine. Look at that for the Mustang. Five stars up and down the board. Extremely safe sports car. I just wanted to do a video on this one because it's been ended the night and it's still got people looking at it. Thanks for checking out the video. Remember to like, subscribe and share on my YouTube channel, which is youtube.com slash summit auto. Check out all my videos from the Chicago Auto Show, hashtag CAS22. Remember to like, subscribe and share. In fact in a second you'll see a link to subscribe to our YouTube channel in the upper left. A link to more Mustang videos like this on the upper right. A link to one of our latest YouTube videos in the bottom left. Thanks again for checking out the video. Remember to like, subscribe and share.


Apple picking season is here in Landsberg Landscape Nursery and Breinerd is hosting their first ever Apple Looza. Landsberg Nursery always has apple trees for sale, but only for this three-day event can you purchase the fruit at the nursery. The apples are locally supplied by Gilby's farm in Aiken and are on sale for $3 a pound. Not only can you purchase the fruit at Apple Looza, but there are demonstrations on how to plant your own trees as well. That's all going on at Apple Looza. There's a lot of people concerned about apples. They want to grow their own. They're interested in local and fresh and we're just using it as a teaching event. We're trying to teach people how to grow apples, you know, that you really only need two trees. You don't have to have an orchard to have enough to feed your family. If you enjoyed this segment of Lakeland News, please consider making a tax-deductible contribution to Lakeland PBS.


Thanks Candice. Thanks Candice and thanks for the Linux Foundation for having us. And today we're going to cover under the hood of a shop per core database Hector. In particular, we're going to talk about CTP. Before we get started, I want to highlight an upcoming event, which is very much on the same topic as this session, the P99 conference, very technical conference, which is all about performance. So check it out if you're interested. And one last thing before we get started, a quick poll on your asking you on your status in NoSQL. Okay, so let's get started. I'm Zakhly Vitan, VP product at SillaDB. Before that, I spent many years in the telecom domain. And after that, a few years in Oracle Communication Unit. And I'm in SillaDB for the last, almost from the start of the company. I think it's seven or eight years by now. So what we're going to cover today is a little bit, what is SillaDB, the company, what is SillaDB, the database. Then I'm going to give you a very quick history lesson, if you will, like five minutes explaining what are the, how hardware and database change in the last decades even, and then how SillaDB was architect to match these changes. In particular, we're going to deep dive into the sharp per core architecture as a title promise. Then we're going to cover something which will break a little bit the sharp per core architecture with the storage and I have a scheduler we built to handle the storage. If we have time, I'm going to present a few benchmarks and then hopefully we have time for Q&A. As Candice mentioned, please use the Q&A tab on your Zoom UI to ask questions. Maybe I will answer a few questions in the middle, but probably I'm going to answer most of them in the end. So what is SillaDB? By the way, who are you here on the call? Are you familiar with SillaDB? Please raise your hand. Okay, I cannot really see you, but just a quick exercise. What is SillaDB? SillaDB is an old SQL database aimed for or designed for very high performance. It's mostly used for OLTP online requests where both throughput and latency is critical. It can handle analytics requests as well, but mostly it's done in parallel to OLTP, not just because there are other databases specialized just in analytics. It's not the case here. The founders of the company and the database, if you will, is Avikivity and Dolaror. The two founders still in the company, CO and CTO. As I mentioned, SillaDB is very much about performance. When I'm talking about performance, there are at least two characteristics to think about. One is throughput, how many requests per second the database or any application can handle. The other is latency. What is the average time to response to a request or, in most cases, we're looking at the P99 response time, because many applications will actually launch many, many requests to the database. Even if just one of them is slow, it can slow down the entire database. Looking at the P99 is actually more realistic in most cases. The third SillaDB is an open source project. You can go to GitHub, download the code. It's in C++, by the way. You can compile it if you have a lot of free time on your hand. Or you can download the packages, Docker, using AMI on AWS or an image on GCP or Azure, etc. If you're really brave, you can try to contribute to the code as well. There is an enterprise version, which is a closed source variant of the open source. 90% of it is the same, but it do have some extra feature on performance and security. A quick example will be encryption at rest, which is only available on the enterprise version. Last but not least is cloud offering, like everyone else. We also have our own manage variant of our database. It's basically still enterprise, but fully managed by the Silla team. You can consume it through the APIs and don't have to run it yourself. The two APIs that we are exposing right now is one is compatible with Apache Cassandra and the second is compatible with AWS DynamoDB. If you are using any of those, you can use the same drivers to work with SillaDB as well. It will just work out of the box. A quick list of some of our customers. I would say that the common between, as you can see, there are many different use cases and many different domain, media, IoT, FinTech and other. I would say the common between all of these use cases is a combination between high availability, big data and performance. If you have only one of those three or even two of those three, you might have other alternative, but if you're looking for a combination of high availability, performance and big data, Silla might be a good choice for you. One thing that this session will not be focused on is the high availability architecture, which of course is very important in distributed databases. In particular, just not the center of this session, which is more about performance. I do want to spend two or three minutes covering that and then we can deep dive or zoom into one of the nodes of this distributed database and explain how it gets to high performance. If you're familiar with distributed databases, in particular Apache Cassandra, Silla inherited a lot of the characteristics from it. In particular, it supports multiple data centers on different regions. Each data center or each region, you can work with different consistency level. For example, I can work with the US region with a local quorum and I can work with a remote region with quorum of one or any. It's what is called tunable consistency. All the data is shared between the nodes, depending on the application factor. I can say that this table or this key space in Silla term replicated in one data center. Other key space can be replicated between two data center or three data center or four data center. We even have customer users that run five data centers. In this case, this is another example of free data center. You can imagine that application in Europe, for example, will use consistency of local quorum. Every read and write request will only wait for response from the local node in this data center. Offline, this data center can be replicated to the other data center. In case of a catastrophe, one data center is completely down. You can still serve the data read and write from the other data centers. Of course, the latency will not be as good as good because application will take more time to work with. This actually was proven to work under fire, if you will. One of our customers, unfortunately, had a big fire on one of its data centers. It was a hosted data center. Luckily, no one was hurt, but out of the 30 nodes cluster, 10 was unreachable, as you can see here on the monitoring, but the cluster just continued to work smoothly and serve both read and write requests using local quorum. I don't want to mention the customer, but if you get the slides, you can just click and see how the customer reported this unfortunate event. So that's all about introduction to CELA, introduction to high availability on CELA on really a quick notion. And now I want to take you back a few decades and give you a quick history of both databases and hardware in the last few decades. And I promise it will be quick, and then I will jump to CELA architecture. So how server or I'm talking about here mostly on production server on the data center to change in the last 10 years or 20 years. So I'm sure everyone on this session familiar with the Moore law stating that the CPU or cores will double each 18 months. So this still is true, although people say it's over or will be soon over. But if you see how the number of transistors actually change over the last few decades, you can see that the number of transistors per core actually flattened in the last 10 years. Also the frequency of a specific core flattened in the last 10 or even 20 years. And that's of course because of physical limitation. There is so much you can hit a processor before it's burned down, as we see in the previous example. What is continued to double and even more than that is the number of core per machine. So if you are old enough like me, you remember that 15 years ago, two cores, four cores was considered, was considered like a huge machine. Now these days, your phone probably have more than one cores. And on the cloud, you can easily get 96 core even more than that for a machine. It's not, I wouldn't say it's not, it's cheap or anything, you still need to pay quite a lot per hour if you are getting a huge machine. But what I want to say that machine become more and more stronger, mostly using more and more cores. So that's a complete change in hardware and VMs as well. And Cilla was designed, as we'll see in a few minutes, to match these changes. Other changes that come with the multiple core per machine is what is called NUMA, Non-Uniform Memory Access. In NUMA architecture, unlike what you might think, each CPU have its own chunk of memory, which is close to it. And other part of the memory, which is physically more distance from it, and that's directly applied to latency as well. So if you will try to read memory, a remote memory from a CPU, you get not as good latency. Again, another factor that Cilla take into account. And when we talk about Cilla architecture, keep that in mind because you will see how Cilla actually take advantage of this architecture, not just ignoring it like an application that was maybe designed or initially designed 15 or 20 years ago, it didn't take this into account. And in addition to the number of cores, of course, if we look at the last 10 or 15 years, RAM become huge from a few gigabytes. Now you can have terabyte of memory. This can storage completely change. Cilla, in most cases, work with NVMe and SSDs, which become commodities these days. And of course, they change all the time. So every new generation of instances, for example, in AWS, the I4I, or others come with more efficient core, but also an even more efficient storage. And I will touch on that later in this session. So in parallel to this hardware change, no SQL or database on general change as well. If database, of course, exists for decades. And if in the up to the 2000 relational database was the king, and everything was around it, once internet or it used to be called internet scale and later called big data, data has simply become too big for one machine. And all the databases have to become completely distributed. The first generation of such databases include, for example, Apache Cassandra, which inherit from the Dynamo paper for AWS. And Cilla is a direct, you can think about as a direct child, if you will, a cousin of Apache Cassandra. But while Apache Cassandra was designed around distribution, it was not designed around the hardware changes we seen earlier. So if you want to run multiple application of Apache Cassandra on a machine, you're more likely to run a few instances on the same machine because it does not scale per core. Because when it was created, this was not still not a problem. Cilla had the benefit of coming as a second generation, assuming that you have a very high number of core per machine and design based on that. So that was concluding the history of the world, mankind and databases. And now we can move forward and step into Cilla design. So what are the goals of Cilla design that was originally built around eight years ago, but still stand today? So efficiency, utilization and control, efficiency, you can translate it to the now throughput and latency, which I mentioned earlier, try to optimize both. Utilization, try to maximize the usage of every CPU or every core on the machine. And control meaning that you try to set your own priority, both to the CPU usage and the data and the storage usage and the network usage. And I will talk more about that later. So what are the design decisions that Cilla is based upon? There are six of them. And I will focus on this session on two of them. So the first one, which sometimes generates a lot of heat, but it's actually not as critical for the overall design is it was Cilla was created in C++. Back then, other alternative like Rust simply didn't exist or there are other languages. But C++ is still the main platform to build such a plot, such databases or high-fast application and Cilla follow the trend.  So all the operations in Cilla are asynchronic. Usually, if you work in, if you ever build a network-based application, you know that every work with the network must be completely asynchronic. In Cilla, we extend that and that will work with a disk, for example, it's completely asynchronic, not just every communication between nodes. Sorry, between cores on the same machine is completely asynchronic. And that's actually a must in our design, which is based on shout per core. Shout per core, I'm going to skip that for now because I have another full section of that. Unifying the cache is another successful, I would say, in retrospective design decision. Cilla manages own cache, it does not rely on the operating system page cache. Because, as I mentioned earlier, control is one of the main goals that we want to achieve. And if you let the operating system manage your own page cache, there is a limit to the control you can apply on that. And you don't want the OS to take over and decide which page can be evicted and which is not. You want to control it as a database. Ios scheduler, sorry, let me move ahead. Ios scheduler with another topic I'm going to spend more time on later, so I'm going to skip it for now. And last one is automation. Cilla has other applications include a lot of parameters that affect the scheduling. So some of it is preset, some of it is determined when you install Cilla, we actually do a quick benchmark to read, for example, the storage properties and fit it back to the application. And some of that are applied online for real time. For example, if the user chooses to change his workload on real time, Cilla tries to adapt. And each of the scheduler, and I'm going to spend more time talking about scheduler later, either the scheduler also have a feedback loop that on real time changes scheduler shares and maybe give more shares to offline processors in some cases like compactional repair, maybe give more share to online request. So this is a high level design decision that Cilla was based upon. And what I'm going to do next, I'm going to deep dive into one of this or two of this decision and the first is Sheldsberg. So if you look at most of the application actually out there, in a particular application like Apache Cassandra, which we profiled back in the day when we started working on Cilla. And most of this application are built on running many, many threads. So it's going to be thousands of threads, actually. And this thread are competing for resources. So they are competing for CPU, of course, every time one of them block, there is a context switch. This is a pretty expensive operation. They are competing for access to memory. So the memory is shared between all the threads. And if a thread need to update to read from memory chunk, you need to take a look first. Of course, a different mechanism to do that. But the result that thread are competing with each other on locks on memory and CPU and actually spend a lot of time doing that instead of their actual work of reading and writing data or serving the database. This model still working in many applications, but it breaks when you have more and more cores. Because when you have more and more cores on your machine, you want to take advantage of them. And if most of what the thread are doing, I invite you to run a profile on your application or your database and try to find out how much time you spend on that. You simply don't get utilization and efficiency. And the main principle that Cilla is based on is actually limitation, if you will. We limit to one thread per core. This thread is never a context switch.  So we have its own memory allocation, its own file on disk, its own network connection. And it will never a context switch away. And this also mean, if you think about it, that this thread can never be blocked. So if earlier, we mentioned that on a legacy application, a thread, for example, when they go into the storage, it will do a synchronous write or read, basically block with the context switch or another thread. And once the storage gets back with a respond that will a context switch again, this cannot happen in Cilla. Because we only have one thread per core. And this thread pinned to an actual physical core, we can never block them. And that's mean that we have to keep everything, but really everything completely asynchronous. So this is a main principle in Cilla. It's not new in a sense that other distributed database already done partitioning of the data and of the computation. But until Cilla, this partition was node based. So if you have a database or an application that run 10 nodes, you would split the data between this node based on some key in Cilla, it's called a partition key with a function that we call a partitioner. But in the other databases can be completely random or based on some data. And so each of the each of, for example, the records in a database will be on a different node. In Cilla, it will be three node because it's replicated. But I think that the principle is the same. You partition the data between the nodes. And you have some deterministic algorithm to understand which information element live on which node. And so you can read and write this information element. In Cilla, we extended this notion and we also partitioned the data between the core and the machine. So in this case, it's a very small machine, only four cores. As I mentioned earlier today, you can do it with 96 cores. And we actually split the data inside a specific node to either four or 96 or whatever number of nodes that you have. And each core thread, as I mentioned earlier, only serve this data. So in an ideal world, nodes or cores in the same machine will never have to communicate with the charger. Of course, it's not the case, because there is materials view, secondary index, another shared information element that node do need to share. And this will be done through message queue. So to summarize this part, if in a traditional stack, and it's say here Apache Cassandra, but this is actually common to most application written even today, not just Cassandra and not just other database. That's our base on many, many threads that are competing for resources. Sister architecture is different in sister and explainable sister in a minute. Each thread is being to a specific core. Each thread is limited to its own data, its own memory. And when thread need to communicate with each other, they will do it in a complete acynchronic way through queues. And if they need to go to the network, they will do it in acynchronic way. If they need to go to the storage, they will do it in an acynchronic way. So this is the heart of Silla, if you will, it's an open source library in C++ called sister. This library, it's actually since introduced, been using many other application, mostly a data heavy application. I would say that sister is a very good fit when you can somehow partition your load to pretty separate chunks. And database is a good example because a database on most cases, you will have many information element which not as much interaction with each other. If your application is one huge computer engine that all information element have to touch each other constantly, this partition algorithm will not work as well. And maybe sister is not a good fit for you, but for many other application, it is a good fit. And since introduced application like Red Panda, which is a replacement for more efficient Kafka, RageDB, a graph database, Ceph, which is an object store implementable, Red Hat and many other application was built based on the sister application. And you can see here, this is actually a very early test with it with sister, testing HTTP server and memcache. One of the nice properties of sister, it's very nicely scaled with a number, of course, because you have a dedicated thread per core, the more core that you add, you simply add, and this is done automatically, add more threads to the system and pin them to specific physical core. And you actually get a linear growth in performance per core. So this was an early design decision by Tsila, but with every generation of new server and more core per machine, this proved to be more and more successful. Because still I can really grow linear with the number, of course. And so now I'm going to break everything I said before. So, so far I mentioned that each core is completely independent, each core handle, its own memory chunk is on storage chunk. And it does not touch each other, but that's not the complete story. Why isn't it? Because some of the resources like the storage, it's shared between all the all the cores in the machine. So it's true that every core, every thread in Silla case, have its own file or file descriptors, and manages own file system. But at the end of the day, the machine have one SSDs. And this SSD or multiple SSD, but sharing a rate between all the cores. So with this SSD share or resource share between all the cores. And this brings the scheduling challenge to Silla. So why do we need scheduling at all? So if you think on a database from a high perspective, database is a very storage intensive application. Most of what the database will do is storing information and fetching information and sending it back to the user, especially a real-time OTP database like Silla. If you run heavy analytics, your database might also involve in computing. But at least in Silla case, most of the work is just written right from the database. But that's not all. There are also administration operation like compaction, which is a Silla offline process that read all the data and compact it. There is a data structure called LSM, which I'll not cover here, but need constant compaction of the data. The other operation like repair that compare two nodes and see the data between them. And all of this operation need to be scheduled. So for example, if you have a heavy load from the user, you might want to hold down on your compaction, wait with them. But if you wait too long, the compaction will accumulate and then we have to spend much time on that. Sometimes we want to give the user some control of the load. So if the user know that you have a less intensive application where the latency is not critical, you might create what is called in Silla workload, which is ignorant to latency and don't care as much about latency and Silla might want to do the scheduling to put it at the back of the queue. So there are a lot of online decisions that are made about scheduling. And this is what the storage schedule and actually do. At the end of the process, Silla is managing all of this queue. And all of the process with actual storage and Silla send all the requests to the storage to execute. And now the question come, how to use the storage? So if you look at more than storage, of course, it's going to handle more than one request per at a time. It actually can handle some hundreds of requests at the same time. But there is a limit to that. And this is a limit that we actually was very critical for us as a database operator or vendor. So we build a series of tools to measure storage performance. And this was the first generation, this disk explorer number one. What you see in this graph is we measure the number of concurrent messages that storage can handle. And this typically is an NVME and SSD. So in this case, you see that up to 100 concurrent requests to the disk, you actually get a better throughput with every new parallel request to the disk or concurrent request. But at some point, this is completely flattened out. So the more concurrences that you add, if you try to send 200 concurrent requests to the SSD, you don't get better throughput. What has actually happened that you are starting to fill up the queue in the SSD itself. So the SSD starts to accumulate requests, latency become worse, and you are not getting anything. On the contrary, you are losing something. What you are losing, you are losing control. Because as long as the database handling the queues internally, it can determine if a specific request has more, a higher priority or less priority than the other and can actually dynamically play with it. But once you push all the storage requests out of the right to the storage, it's accumulating the queue and you lose control of the priority. So we are losing twice. First, you are not actually adding throughput through more concurrent requests. And second, you cannot longer prioritize a request. And of course, that's not what we want to do. So the first generation of SILA actually did this kind of benchmark in SILA install, took these properties of what is a sweet spot of its storage and feed it to the online scheduler. And this was working good enough for many years, but actually break on the latest and greatest machines. And we have to change it. Why did we have to change it? Because SSD become more complex. And the naive assumption that we took, which was right at some point, there is one sweet spot of concurrence request break because it's not that simple. The actual picture is more complex than that. And if you look at the spec of the latest SSD, and let me zoom into this part, you can see that as an example SSD can handle as much read per second and much write per second with specific bandwidth. But what this spec sometimes not is explicitly on that you can only do one of those at a time. And if you try to run a mixed workload, which include both read and write in different sizes and different bandwidth, that's of course not surprising, they affect each other. So if you do read and write on the same storage at the same time, they will slow down each other. And it's sometimes hard to predict how they will affect each other. But we as a database vendor or a database, if you will, must predict that because we want to control the number of requests that we're sending to the storage. And this is where we introduce what we call disk explorer number three, I skip one generation of disk explorer. It's another open source tool that you can visit on our GitHub project. And this tool is more sophisticated in a sense that unlike the first generation of disk explorer, which only found one sweet spot of concurrence request request per second. This generation actually test with a lot of that or generate a lot of data points, each a different combination of request per second and the size of the request and do it independently for read and write. So we built a more complex, a more realistic and more complex picture of how a storage actually behave. And this is different kind of hard drives and produce different heat map of the storage. And what we aim to do with this not very complex formula is try to find not one sweet spot but an area on the graph that we should work with and not go over. So this is, you can think about it as under this red line, it's a safe zone when the storage continue to serve. If you try to work over it, the story will just again start to queue the request on its internal queues and sometimes there is more than one and you no longer, you should no longer put more and more concurrence request because it will just be queued. And as I mentioned, you are losing ability to the parameters, etc. So this is the new disk explorer. As I mentioned earlier, this actually is a quick benchmark that we run when we install Silla. Or if you are working on the cloud, which most people do these days, we actually have pre-configured value to popular instances like i3 and i4 and you don't have to run it to yourself. You just pre-configure because you do get pretty consistent performance of storage property from each of these instances. And that's bring me directly to the latest and greatest i4i instances. And this is how the same performance map look for i4is. You can already see it's much better than i3. And AWS was kind enough to give us an early access to these instances, which are now publicly available. And to summarize our result with them, they are actually getting more than twice the throughput compared to i3, which lower latency. So it's true that the price are a little bit higher. But if you look at the performance per cost perspective, we highly recommend i4i for Silla usage and probably for other database and application as well, at least if they are storage intensive. So definitely want to use that. This is another test that we did compare in i4, i3. And this right bar that you see here, it's a three-node cluster with replication factor three. So as you can see, each of the nodes in this cluster can serve way over a million requests per second. This is a huge number. This is just a three-node cluster. So imagine if you are running a 20-node cluster or 15-node cluster even more, how many requests per second you can serve a lot. And this is all while keeping a very low B99 latency. And one last thing I want to mention is a benchmark that we did with PETA scale data. So Benny, one of our leading engineer, tested not actually not with the latest hardware, he still use i3en machine, which are also very good. Not as good as i4i, but still very good and with more storage per CPU ratio than the i4. So we use quite a big cluster of 20 of these machines, of big machine and was able to serve a petabyte of data. As you can see here, while keeping a lot of data on the database, we can still maintain very low latency. I'm talking about B99 latency of both read and write with very high throughput. And I'm not going to deep dive into the numbers here, but if you're interested, there are links. So to summarize what we've seen here, SILA was built with performance in mind from day one. And the main principle that allow us to implement this high performance is the shaltperko architecture, which come along with completely asynchronous architecture. There are a lot of other factors of this performance, which I didn't mention. Actually, most of what we did in the last eight years and what we're doing today is improving performance. And it's have a lot of different aspect like more sophisticated compaction strategies, and a lot of strategy of reading and writing from the disk and many other things, which I didn't touch today, because I wanted to focus on the main concept of the shaltperko and asymptotic. But if you are interested in building high performance application, I highly recommend you to look at SILA and SILA code even. And what the two principles that I mentioned start that performance can be split into throughput and latency. And while they are different, at least in my mind, throughput is something that can very easily converted into a reduction cost. Why? Because if you are doubling or five times the throughput per node, you actually need less nodes. And that's automatically, of course, can be translated to expense of the cloud, where most of application run these days. Latency is more tricky, because latency you cannot really solve by throwing more money to it already more machine. If you want to achieve low latency, it's much harder. And this is where SILA shine, especially on the P99 latency. And as I mentioned at the start, we have a specific conference coming up just on that. And with that, let me switch to a pool. And after that, we can start the Q&A. Okay. So let me switch to the Q&A. By the way, you can still write question on the window. First question here. Do SILA have its own property driver? So the answer is yes and no. So SILA, as I mentioned at the start is compatible with both AWS DynamoDB and Apache Cassandra. So every application that you have, the TRUN, for example, work with Apache Cassandra can work as is with SILA, because SILA is compatible in the protocol level. So in the binary level of the protocol, so every driver that work with Cassandra will work with SILA. But there is an exception for that. We implemented a performance specific feature on a fork of this driver, and recently implemented a new driver from scratch in Rust. So I do recommend you to work with SILA driver where you have one. So for example, if we're working with Rust, Go, Python, C++, Java, there is a specific SILA driver on some languages and environment like JavaScript, there is no Tieta SILA driver. So the Cassandra driver will work as good. And the same goal for DynamoDB. For DynamoDB, we actually didn't develop our own variant of the driver. So every driver like Boto and Python and other that work with DynamoDB will work with SILA. So a question, if SILA was built today, was a design decision, would be different? Good question. Probably not. I would say, and it's a lot about the knowledge and what developer feel experience with. I would say that we are very excited about Rust these days. And this is why, for example, we are planning to build a lot of the SILA driver based on Rust, but I'm not sure that the entire database can be built just with Rust. We are taking a lot of, I would say that SILA need a lot of control in the memory allocation and the way that the database build, which at least seven years ago was only possible in C++. Maybe it's different these days. So that's answering one question. Second question. SILA rely on Async Direct IO. Yes. Does it imply we must use only this supporting? So no, we do recommend running a file system, XFS file system, which work nicely with Async running request. Probably you can try to use, and some people actually do use old hard drive, not old, sorry, spinning. It can be very new and actually work pretty fast working a hard drive SILA. But on most cases, our recommendation is to go with SSDs. There are all kinds of combinations that people run in creating rate one and rate zero across legacy spinning disk and actually getting pretty good results. So I wouldn't rule it out, but I would say that the main and most of the user are actually using NVMe and SSDs. Okay. Very interesting question about Cassandra support asset transaction. Does SILA also support it? So it's first of all, Cassandra does not support asset transactional production just yet. It's a recent proposal and the PR, which we are very excited about, but it's not production ready yet. I just want to mention that both Cassandra and SILA do support lightweight transaction for quite some times. At least in SILA, it's production ready, but it was not really popular because it didn't get good enough performance compared to the eventual consistency alternative. But in the last two years, we invested a lot of effort in implementing the raft consensus algorithm in SILA. And in the next few release, we are starting to graduate it to production. The first feature that will be graduated on on top of raft for production is actually strongly consistent metadata. And by metadata, I mean, for example, things like the schema and the topology of the cluster. If you work long enough with both SILA and Cassandra, you probably hit schema synchronity between the nodes. And you hit the fact that you can only add one node at a time. So moving metadata to raft will actually solve this problem and many others. And this is something that we're going to roll out in the next few months. And right after that, we will start implementing actual data strong consistency, acid consistency, if you will, over raft. And we are very focused on right now in implementing and mostly testing it. And the main focus is always the SILA's performance. So we are not we're not adding features which are not great, great in performance and have superior performance and everything that we built, we are very cautious about not to introduce new latency. For example, in SILA, we have something that I'm not aware of in other databases. We have like a built in sensor, if you will, that measure the latency. And if it's that one of the tasks in a specific thread take more than a few microseconds, it's write an error or a log to SILA log because we are handling each latency as an error. So even if a task take more than 200 microseconds, even we'll treat it as an error, open initial for it and try to fix it. This is why adding a new feature sometime take a little bit longer because we're investing a lot of effort, not just testing the correctness, which is super important, of course, especially for us in transaction, but also making sure that this new feature will not hurt performance. Because this is our pride and joy, I would say, a database which is which super high throughput and very low latency. And so it's can be very easy to break this two rules if you start randomly adding features. But definitely, Asid is on the roadmap. And if you check a past presentation, for example, by Costia, our lead developer on the raft, I did a webinar within a few months back when he deep dive into the algorithm of raft and which is completely out of focus of this session, which was focused on specific not performance. But of course, it's critical if you look at the complete distributed database, the consistent algorithm are very important, just not today in this session. Okay. So thanks, everyone. I don't see more question, of course, feel free to jump on a slag or drop me an email after I will do my best to answer a more question if you have them. And with that, let me turn over back to Candice from the Linux Foundation. And I want to once again, thanks the Linux Foundation for hosting us. Thank you so much, Zach, for your time today. And thank you, everyone for joining us. As a reminder, this recording will be on the Linux Foundation's YouTube page later today. We hope you join us for future webinars. Have a wonderful day.


Everybody Matt here for late in sports cards are up in one box of 2022 tops pro debut baseball Jumbo for Thomas W Good luck Nailed some card dust there. I think L. Adela Cruz Miranda and nice Ryan Holgate gold paper auto It is 17 of 50 Nice gold auto home Beach Cardinals Good start to your box Torres, Bobby and Bray you throwback and auto Ian Lewis There's Aqua to 75 Nick Gonzalez Lara Jose Torres aqua paper to 75 Arcello Jordan Viers refractor variation to 99. Oh Tomorrow night now I'd be forest I'll be doing daytime breaks over on the baseball channel Hey, man, thanks again for that glove kid loves it Paulson Watson is Bo Jackson and Blue paper auto to 150 Reginald press the auto Nice one to 150 so a gold and a blue auto in this box Sorry Card dust got to me short McCann's blue mingas Savala and orange paper to 25 Alexander Canario The South Bend Cubs Go to 25. I actually went to a game their inaugural season when they're the South Bend White Sox Eric Pena gold refractor to 50. Oh nice. Yeah, awesome And that that'll probably be us then the last pack for you Thomas shot Knowles Okay, hey girl a own Derek Lee Colson Montgomery and paper on the back Alright, that'll do it for your box. Good stuff. Appreciate the purchase. We'll get these right out to you