Mastering data types

so what is the difference between a list and a set anyway today we're going to be talking about all things data [Music] types we are taking things back to basics today in this video we're going to be looking at data types in both terraform and bicep now I can't leave this alone so I'm partnered up with my friend and colleague Jack Tracy who like me is part of the aszure landing zones and Asha verified modules teams here at Microsoft we're going to start off with an introduction followed by some

Hands-On stuff in both terraform and bicep it's a bit of a longer one today so we've put some chapters on the video to help you navigate I hope you enjoy uh so Matt so anything to add around data types like you know obviously pretty fundamental right like the probably the first thing we all have to learn but probably all skip past very quickly yeah I agree I think it's really important to learn the nuances of data types for your particular infrastructure is code language there are some real Oddities I guess you probably call them inter terraform man andu bicep too so yeah when we come on to you know how do we

have a decimal number in bicep or what's the difference between a list and a set in terraform so so that's what we're going to get into today it can confuse a lot of newcomers so yeah we hope this is useful absolutely and which goes saying we're going to get into some actual Hands-On code as well uh towards the end so make sure you stick around for those as well so let's first jump into some of the the like the core elements or the the foundational pieces or the foundational data types so we have strings numbers and booleans these are like the atomic values right you can't

really get any smaller um data types than these elements uh in any infrastructure as code language obviously from a programming perspective yes you can but we're talking infrastructure as code here so a string is literally a string like this is a string you might commonly see it wrapped in uh double quotation marks or single quotation marks uh a number you may not you won't see wrapped in quotation marks it would just be the number the digit so three four five whatever um and this is where actually we got some differences already between between terraform and

bicep so in terraform they actually support some things uh as a number uh called integers and floats so integer is a whole number so one two three um but a float is a number with a decimal place in it it's got a floating decimal place in in the number right hence why it's called a float so you could have like 1.5 2.7 3.9 now in bicep that's not a thing that exists and is not supported today and we'll get on to how you handle that at a later date but you can't use floats so there's only integers in the

terms of bicep um but in terraform it's just declared as number right map as a DAT Tye just one type and it works out the best way to store that behind the scenes if it's a decimal number or if it's a whole number awesome that's really good to know um and then we also have uh Boolean which hopefully most of you are familiar with which is literally true or false again you won't see this wrapped in quotation marks quite commonly it's just true or false if you do see it wrapped in quotation marks it's a string right but with the same

same thing so just be aware of what these like little things mean um moving on from this we have some more composite um values things that Stitch multiple values together right so in this example we're showing here uh we're showing an array or a list as we may talk about in terraform um and this is as you can see it's an array of strings so it's one two one but they are all uh strings that are wrapped inside of an array and that's

shown by the square brackets either side of it on lines one and five here um in terraform they have to all be of the same type right mat like so they all have to be strings yeah so if you're going doing this in terraform when you define if it's a variable you'll say it's a list bracket string in this case and it'll be a list of strings and if you try and put anything else in there it will complain and that's where we get another difference again uh in bicep you can mix them up so I could have one two and one here declared as strings and then I could put the number values or

the integer in bicep as one two and one as the digits uh and that'll be absolutely fine I can't say I would advise doing that it's quite quite a nightmare to to manage and work out what's where and what what's what's there um but it can be done right and I think that's that's something just to note like it can be done doesn't mean you should should do it um and then Matt we've got some differences on the terraform side right around arrays right we have something else called sex you want to those absolutely something that's of confused so sets come from do

you remember ven diagrams at school do you remember them oh yeah yeah those who like apples those like oranges those like both well the point is that those are real unique outcomes uh of that scenario and that's what sets are that comes from a set theory so basically what that means in the real world is you can't have duplicates so you have to every value in a set has to be unique the other key difference is that it's not ordered so if you took an array or list and you you R you did a for Loop over it you always get the things come out in the same

order because that's the property of of the array or the list whereas in sets you cannot guarantee it will come out in the same order so you do not rely on a set for ordering if that is important to you but if you want very fun in terraform right especially based on some of your recent videos around like don't use uh for Lo or count and stuff like that like that could be fun yeah no absolutely so um it's it's it's a really good way of of of um making sure you haven't got duplicate values so you can just convert your list of strings to a

set and all of a sudden you've got a known unique list so yeah that's a really good point and actually I missed the point on on the previous slide around AR rays that they're always the same order right so uh if we just quickly flick back you know one two one here they'll always be at position 0 one and two and I think that's also another key point to call out that we maybe have skimmed over is arrays each of these is known as an indic or an index and they start at zero so at this example number one here is actually array index

position zero so always take off one when you're trying to access something in an array and we can show you that later as well um and again that's really important with the same with sets right they still have an index position it's just obviously they'll be unique I would take it and you what they are think I don't think you yeah I don't know actually it's an interesting one maybe I'll try that in my demo later and see what I can let's give it a go let's see what we work out um and then we've got objects right so defined by squiggly brackets or mustache uh mustaches if you want to

call them that um and these can contain different types uh and they can also be nested so in this example we've got a which is a string B which is a number or an integer on the bicep side and we got C which is a Boolean here um and they can all be declared in a single object and happy days and you can Nest this so this could have an object of objects inside of it and we're going to show you some examples of that also uh in terraform they're called Maps right Matt uh so these if it's only a map if

you've got kind of a nested uh one of these These are called objects um but it's kind of it's kind of a blurred line between maps and objects it's a bit odd but if I said this a map to you you'd probably know what I meant uh yeah I I would but in strictly speaking it's an object but yeah Fair cool all right and then we've got some this is actually a map right so I think this leads on nicely so over to you mate might it might sound really confusing

but ultimately a map is an association of a key and a value now in terraform and I think in bicep as well the key is always a string because it comes it basically represented an adjacent object so what you're what you're essentially doing is looking up a value by its key we use this a lot in terraform um as you hope hopefully know if you're watching my video on using for each the right way map is the correct way of using a for each to get multiple resources and what we typically do is the value of that map

is is an object with a schema which represents all the data you need to create that resource um so yeah you can also have nested Maps so it gets really confusing sometimes um but but yeah I think hopefully this will make more sense when we when we come to the Hands-On stuff and we can kind of show it for real it will hopefully sink in yeah ultimately a map is just accessing a value by its key so you can see an example on the screen actually you've got my key so we' be able to access the aals F Bal 3 data by referencing that my

key and we get that value out of it yeah and I think also a point of note in bicep this was still be declared as an object um but sometimes commonly referred to as a dictionary because you're using that key to look up the value so you can think of it as a dictionary right you're looking through a dictionary to find the starting point to then get more data about that particular thing um so that's that one and then we've got NOS right Matt do you want to talk us to about NOS yeah so in terraform um any type of object can be have a null value now it's not the same

as an empty value so you when you're making your Expressions inside your terraform modules if there's a possibility that the value can be null you have to test for both null and an empty list so actually it's a really good practice on um variables that have collection values to set the nullable equals false property because then if someone passes in a null value terraform behind the scenes will just change that to an empty list so you don't have to cope with both those scenarios in your code you can just assume it'll either be a list something in it or an empty list

rather than having to test for null as well so yeah null null is a is normally used to say I don't want this in terrial okay you won't quite see it that as often I would say in bicep from from my experience you'll quite often see people declare like default values for parameters as empty strings insinuating that it's not needed and then they'll have a like a condition that says hey if this is empty then don't do this or do this um so we don't see this quite as often in in the bicep world but NS do exist for some uh properties of

resources as well just want to come back on that set point just uh I've been tacking away in the background and because sets are not ordered you cannot access their properties by index so you can't go my set zero because because they're not ordered you can't guarantee the order you can't reliably get that value back so yeah there you go there you go on the on the Fly learning which we love um absolutely so I suppose should we try and make this a bit more tangible right for people watching along so uh should we dive into some terraform first

uh yeah cool let's do it um okay all right let me get your vs code up here we go so I've got a load of locals defined here and I'm going to use going to be using a feature of terraform which is way underused and is actually super useful called the terraform console so I've got a local I've got some stuff in here like my string my empty string my number is string so we're going to be looking at some value conversion stuff um my ball and you'll notice I haven't had to be explicit mostly about the

types here ter will assume that because I put true like that that this is a Boolean if if I was declaring this as a variable I would put the uh type because it's good practice to tell terraform what type is but with locals you can kind of be a little bit more lazy about it so terraform will make these two numbers it will make that a Boolean it make that a string it's got quotes the difference is when I've got this thing like a list here that's a list of strings but if I was explicitly want it to be a set I have to I use the two set function to say no I don't want you to

be this to be a list I want it to be a a set so yeah we also got slightly more complicated stuff like nested list so lists of lists um and then we'll move on to objects and stuff so let's start doing stuff in code so I've already run terraform init here so all I can do now is run terraform console uh and then I can just go local. my string and it prints it out so that's cool and we've also got some text functions here here I can go

lower um local myring prints out in lower case awesome yeah easy I we also got interpolation as well so if I go this is INTERPOL interpolation and then I go that you might have seen that syntax before it puts the value of local my string into that string so yeah really common use case for building up strings containing I don't know resource IDs or whatever right names commonly right like everybody's got a name function with interpolation it somewhere exactly uh so

we got my number as string as well so local my number as string if we've accidentally got that you know sometimes an API might return it in that format or it's embedded somewhere else so we can just use a uh the two number function and terraform will return that as a number pretty straightforward right pretty straightforward I was you're using ter form console here Matt um like this is not the only way that you could do this thing right of handling data locally like we could declare it as an

output and then run a plan and and apply and get stuff out that way it's just a faster way of doing it right it is for yeah it is a faster way of doing it you could easily drop an output uh in here and just run terraform plan it would tell you all the information at plan time um which is fine but sometimes it's nice to just mess around with it in here a bit faster although you don't get the nice uh syntax highlighting like you do in the main editor um let's move on to slight more complex if I H local. my list that's a list of strings there you go

and local. my list Z is hello my list one is world right so that's how you access the individual items in a list doing what we did earlier my set of strings is how is this look look at the order way around right it's almost like the first and the last one the wrong way around yeah it will be random as well it won't yeah so you cannot access it it like that it will moan at you so how do

you yeah how do you access it you access using a for Loop so you go you essentially go if I want a I want a list here so I can go for Value in uh and then I can put value right this is really this is going to Output the same list but that's how I access them right I have to Loop through them and then put your accessor at the end right yeah well then then I can put if um V equals um that and it would only output that one CU I filtered it now so yeah you

have to and you could use them for each and all sorts but um yeah so that's um lists uh list index to objects that's the next one so if I go local. my object we've got key one and key2 which is exactly the same as we've got up here key1 key2 so if I want to access a particular property I can just put another Dot and go key one and it'll return me that that's cool um so that's

how we do that we've then got my list of objects which is going to be a bit more complicated so my list of objects uh and that's going to print out everything because it's a list I can use an array index because it's that I can go key one and pull out the data that I want using that notation so you can see as you can start building up this stuff you can access just the data you want um so Maps we maps are used I used a lot so um it's

worth spending some time learning how they work my map of objects and especially map of objects now it's really important in a map of objects that all of the objects in terraform have to have the same schema so in this case it has to have a key called key1 and a key called key2 and notice there if I didn't have that it would moan to say that all the values have to be the same type so yeah so there's my map there now the way we access Maps is by using the square brackets and then the map key which is always a string so we can access the first one in there so we're accessing

one and we've got key one and just like we did before we can then put a dot key one and then get the value one out of it yeah and that is that's it um changing tack a little bit you might have heard of Turner Expressions now these are real basic if this then that type type stuff so let's go like um local do myb is it yeah yeah my so this is a thing that's set to true but using

this Shand turnery location I can say Okay if that is true which it is you put this is true and then you put a code on and go this is false uh from you can't do that because uh what is that supression sucessfully pass extra characters were found I know that worked before I got try here I know uh my

number is oh local dot my number is that so if I can put local my number if I can put this greater than a thousand which it is then I'm going to put greater than thousand and then if it's not greater I'm can put less than there you go that one worked right the other thing I can do is uh I probably just made a stupid mistake and didn't Spot It can put that in the bracket and then go not so if it's not

greater than a thousand so that's I obviously could have just flipped around this as well well aware of that so yeah but yeah there's lots of different ways of writing them basically um so yeah that's basic tary expression so if the expression on the left of the question mark is true or false then do the first thing or the second thing depending on the result yeah and true is always the the first right so it's question like condition uh question mark true colon false yeah absolutely so it's always

that way and it's the same in bicep as well right we're going to look at this in in bicep as well it's exactly the same um so yeah I would say like this is this is all really useful stuff I said what's the reason we do this Matt like I know me and you do this an awful lot for me personally it's it's to speed up like working out if my conditional logic or like any logic I've got within my module is manipulating the data in the way that I want it to be manipulated and then that final value that I'm getting as an output and passing to maybe a resource or a loop or whatever is is as I expect

it to be formatted before I go and try and deploy resources or do anything like that and slow it down yeah absolutely so it's exactly right it's it makes it shortens the dev Loop for for module development um and once you've got it correct and once you've got your logic correct what you should actually do is R test so I'll I'll do another video on terraform test but that's a new feature in 1.6 um that came out that's really really good so it's all very well testing it now when you first start your development but then as the module

changes and evolves you need to be able to repeat those tests to say is this still correct have I have I messed something up with the changes that I've made basically so yeah we'll come on to that later but yeah all right so yeah so we've shown four Loops we've shown object access we've shown loads and loads of good stuff there's a couple of functions I want to go through and then I think we should do some bicep stuff that cool cool so one one uh so we got loads of functions if you just uh search for terraform functions you'll find them out there so um and we'll leave some links in the description to if so you

can find these pages so you can check these out that's a good idea yeah so my object so if you just want to return the keys so the keys of my object are key1 and key2 so you can see there so that's a good way just the list of strings um Coes is what we use a lot uh which is just give me the first non-null nonempty value so I can put null in there uh empty string and then a string and it will return me the the first one

that's not empty um obviously that's using literals so that doesn't really make much sense but when these values are uh in terraform they you don't know if like sometimes in your module you'll be like if if the caller supplies this variable then use it if it doesn't Supply that variable use a default value um which might be a name for something or something like that so that's the typical function that we use but yeah I'm going to leave it there I could go on a day so uh yeah and I think this is I think as you're pointing out right like terraform console is great because can just keep going with these functions and like oh I wonder how that works or I

wonder how this works and do what me and Matt have done here right just build out a very basic data structure of loads of different types lots of different things in your locals just go and play can't break anything right like that's that's the key here you can just crack on and understand how these actually work there's no there's no provider here right it's not even talking to the cloud it's just all local so it's really safe yeah and don't even need a connection to the internets you can do it anywhere you can yeah um so yeah's let's dive into a bit of biceps so as if by Magic here's my vs code that looks pretty similar um

so again we've got things declared here right so uh we've got a string as a variable um and you'll notice in bicep it's single quotation marks now um if I was to put double it would say hey you don't need to do that in bicep you can use singles or do reducing the amount of characters they're using uh we can see we've got some booleans declared here some integers but you'll note that uh I've got a float declared here but commented out if I uh uncomment that you'll note that it's like hey you can't use this in bicep right so you would typically declare them as strings um if

I'm honest uh in bicep uh and then you know manipulate them if they need to be passed in any different into the resource but quite commonly they're just taking the strings uh we got arrays and you can specify these in multiple ways and I the same is true in terraform right we've got a single line array which everything's on one line and then I've got an array of the same thing but it's just on multiple lines that's interesting so you don't need the commas in bicep yeah so in bicep we we've got rid of the need for commas now um when it's a multi-line array because it knows the new line is uh is the next thing so

yeah that's that's quite good fun um which is a bit odd when you're looking at is from like a Jason perspective you're like I'm missing commas speech marks like all sorts of stuff like down here like we've got a mixed array which we said obviously don't don't do but you could do um and like I haven't put had to put any commas at all like it's just just done it and actually if I put a comma it's like whoa whoa like what are you doing like you don't need this um so it'll help you out the ID is pretty good now um we got some object so we got two objects here both of the key and a value

uh we got an array of objects pretty similar to what Matt had and we've also got a dictionary so a nested object of two different uh objects inside there item one and item two um so let's let's do it a bit differently now unfortunately bicep doesn't have like a local terraform console uh concept it is something that's being discussed in the GitHub issues uh on the bicep repo so go and add your comments over there like that they are thinking about doing something like this which would be be great to see um but so we have to declare the these all as outputs so if I just uncomment this first one what we

can do is print string one so if I go to string one and I just say go to definition we just want to print out this right how it is so this is a string so if I go down here and uh just go back to the output and save that and I'm going to use the new deployments pain experience which if you've not got the latest uh vs code extension going highly recommend giving it a go um and then I can say here deploy so I haven't got to worry about doing new AED Resource Group deployment or anything like that I can just hit here and offer go and it will run this deployment to an arm so you do

need a connection to an Azure subscription at this stage unfortunately um but I can see here outst string return this is a string so perfect doing what I want um we can do the same for an array and I'll I'll take out the last one as well uh and let's deploy that again and we can see what we get back here so we should see the array at this stage outputed um with no filtering or anything like that so we've got one two and three uh and if I was to change that to the mixed array for example array three I should get back the the mixed array of like one two three and one two

three declared as text and integers this is pretty quick isn't it that it's because it's not deploying any resources I guess it's really throwing yeah just throwing a blank arm deployment effectively with just locals effectively is a good way to think about right a variable is a local is a good way to think about in a bicep term um and just saying hey arm engine take this give me an output back you don't have to worry about not waiting for any resource providers or anything like that we're purely in interacting with the armed deployment engine at this stage so it is pretty quick um which is useful you do

need an internet connection though so when you're uh developing on a train like I have done in the past can be quite frustrating um but hey you know it's better than better than nothing uh so we can see we're getting these values back that's all good stuff um what happens if I wanted to print the first item in this uh array three right I just want the number one back so we can do the same right we're putting the array followed by those square brackets and I should just get back the value of one here um so let's just wait for that to

to run and as you can see all I've got is the number one so nice and easy easy way to to keep going with this um if I wanted to Output a string right I think this is one thing that's key to note here and I'm not sure if this is the same in Terra format it's been a little while I have to declare the output data type that it's going to get so I have to know that at position zero is going to be an integer returned but if I change that to string for example it would go whoa whoa that that isn't a

string like you're not going to get back what you think you're getting back um I assume that's the same in terraform so outputs can have types I recommend they do have a type but I think there's like the Catal any type but I hate it yeah I I don't don't use that so yeah I would always be like yeah this is you're expecting a string or you're expecting an object or whatever yeah no that's that's good advice and as you can see here i' had to say that number position three in this array which is fourth in the list if you think about it because they start at zero Z I'm going to get one back as a string but again if I

change that to integer it's going to be like whoa that that's a string you can't do that so the ID will help you out along the way that's really cool so let's come with that actually sorry I need to correct that the output the output type in terraform is the value that you're outputting you you can't Define it explicitly in the output but um you should always use explicit types in your values not any so yeah if that makes sense no that that does indeed so that's quite cool so you would

effectively saved some characters here you wouldn't have to type what it is um which is which is nice um we can do the same for outputting objects um so if we output this object here we'll see um an object with one attribute or one property so just a key and a value um here it is key and value and if we were to then follow up on what Matt was doing we want to access that and again because I'm using here I can say hey I just want the key and it's reading that data uh for me I can then hit deploy and we

should only see value returned uh for this out object attribute which we'll see so we see the out object which is this one here and we're seeing out object attribute which just return us value so good way of visualizing all this um and the same exists for um dictionaries I won't uh I'll output this one here but let's just look here so we've got one here print an we want to take item two's key right that's what we want to see we know it's a string so

let's hit deploy there and we should see both we'll see the the uh dictionary in in its full output so here it is so it's as you can see it's got two items in it um and we want this value we want uh item 2's key which is this one here and as you can see we've got another value so all working as we expect now if I pull this back over and you can see that's how it's declared here we're saying we want item two and then we want want the key I think a difference there right Matt is I don't have to declare

that in square brackets I could um but I don't need to I can just do so ter terraform works with both types to be honest so you can actually use that notation in terraform um there are some in cases where you can and can't but um what quite nice and terraform oh can you do that okay yeah yeah yeah I think you have to then wrap it in yeah sorry singles bad I could but it's like who yeah you don't need to do this like you can do it without use do

notation but if item two is going to be a parameter or something then you might want to use it in that syntax so you can essentially build up that string based on the parameter is that a good use yeah and like also if they've got like weird like hens and stuff like that in like characters that aren't natively supported in the language and you have to wrap in strings then you would need to do this stuff um we had to do some of that in the AZ bicep code if you're look at some of the policy stuff we've definitely done it um so yeah as you can see it works absolutely fine item and

then I can use Dot and I'll get intellisense and say key2 so like all fairly easy stuff I just need that to be key because it's not a string but as you can see all all output absolutely fine let's let's get a little bit more complex though right so this is something that I don't think you have in uh terraform but is something that exists in biceps so sometimes if we look at this uh data type for this dictionary let's say that um you said m that every item in a map in terraform has to be the

same has to look the same every value has the same yeah yeah so for example in here if I was to say key3 existed in one of these items but not in another in terraform would that kick off or would it be like that's fine if if the key didn't exist at all yes it would however most people would just set it to null but but yeah you're right if the scheme is different it will complain yeah so in B out I can have that where it might exist in one but not in the other and that's okay um and you need to be able

to handle that sometimes right it might not be passed in as a parameter so what we can do here is something called a safe accessor so you'll notice there's this question mark after the item before the property name so before key3 now obviously you're saying hey key3 doesn't exist the ID is getting well ahead of itself and being useful so it doesn't exist but what I can say here is if key3 doesn't exist this is KS Shand for Co in biceps I could type out KS as you did um return

this so we know key3 doesn't exist in this this dictionary here in item two so we should get back just the default value so if we hit deploy so while that's doing that is that that safe accessor if you didn't have that cols would it just return null if I didn't have no it would fail oh right okay so it fail the arment because it'd be like there's no value like what do I do like and it would fail so this is why it's h it's a fairly uh new thing to bicep um but really really

useful when you especially when you don't know what the object you're getting in is coming or could be different you can basically say well if it doesn't exist then do this right so a bit like the same example it's just another way of handling before we would have to have done like a loop and gone like if it's empty then do this right and it got long so this is a really quick way of Define it and if you look at a lot of our AVM code samples we do exactly this okay for a lot of our inputs in terraform we have a a lookup function

which can do similar things so you can say look if this key exists then return its value if it doesn't then give me a default so yeah yeah and this is effectively the same way of doing that right just a bicep flavor of doing it um but again really easy way to quickly test what this function is doing um a couple more and then I think we we'll wrap it up but let's uh have a look at uh a turn a turnery condition right so bull one is currently true if we go to its definition bull one is is true if we go back down to the output we're going to say hey if ball one is true then

return ball is true and if it's not return ball is false right so very similar to what Matt was doing and very similar syntax like identical almost right so a lot of these things are you'll find the same across languages uh and if we look here ball is true fantastic now I could do the same as Matt I could say not and I could put an exclamation mark and that would flip it uh and that would that would work as well um or I could actually type not and wrap it in Brackets but that's just a

shorthand way of accessing it uh in bicep uh so we should say see this is now ball is false because we're negating the first one um and we can do you know mathematical like is in one less than 10 so int one is currently one as we're seeing here from the IDE so int is less than 10 um and the other one will say in is greater than 10 so let's hit Deploy on that and drag this back out and we'll see in a

second in is less than 10 because it's one so perfect we're seeing that right very very easy stuff uh and much easier to write in bicep than it was back in arm templates which is great to see oh yeah um and we've got the same things here so I'll just show all of these very quickly like we can do some Mass we can do some upper casing like to Upper and we can do some complex stuff like a Lambda function that's like hey just give me key2 back out of every item I don't want to see anything else I just want two out of all of them and give me it as an array so we'll do a bit of a

grouping of of outputs here for time um so we should see an uppercase string of string one we should see int one and int two added together and get the resultant value and we should see an array with only items from the array of objects which I'll show you up here very quickly so this array of objects where we only want key2 return from each uh object in this array and so if we now look down here on the right hand side this is a string has been capitalized or uppercased we've got out maths added

together because it was 15 plus one from the integers uh and we've got the array of true and false which is just the values of both of those keys that we were looking at just up here um so true and false um so yeah that's it so very similar but again one more step like it has to connect to Azure and you have to have a scope to deploy to um but you know still fairly quick Dev Loop really easy for me to go and test out my logic and when I'm testing really complex stuff and I can't get it working and I'm

like right I just need to strip this Back to Basics I'll rip out the data into a local bicep file and then I'll just start doing this as deployments and forget about deploying resources get my data working and then put when it's working put all the logic back and start trying to deploy my resources just to try and uh speed up getting the time to the fix that's really cool it's really it's really great way of uh speeding up your death process absolutely well hopefully people have got some real value out of that I I appreciate there's a more lengthy one um but you know we we'll

chapter this up so that you can skip between which language you're interested in um any last passing thoughts Matt no I do wonder if we should maybe make the test files available somewhere on a GitHub gist or something so we can put the link in the description maybe if people want to take it yeah um absolutely it's a good idea so I hope you enjoyed that this video has been cross posted on the CAE YouTube channel and the links will be in the description below along with the GitHub gists and everything else that we have used if you've enjoyed this video

please consider liking and subscribing as it would really help me out thank you and see you next time