{"id":"QIHRD45eRHg","title":"Deep Dive into the Daml Compiler","description":"📋  To get started with Daml, visit https://bit.ly/trydaml\n📖  Check out our blog https://daml.com/blog/engineering/\n\nIn this video, we deep dive into the Daml compiler, and help you understand the relationship between Daml and Haskell, and the individual parts of the Daml compiler. #daml #smartcontract \n\nChapters\n00:00 What is a compiler\n4:38 Critical Path\n5:38 Full Build Pipeline\n8:22 GHC, Glasfow Haskell Compiler\n16:59 About Repos\n18:05 Daml Build\n20:54 Shake\n23:23 Install Dependencies\n24:15 Generate Package DB\n24:41 Build DAR\n25:21 Compile Single Module\n29:40 Parse\n37:05 Preprocess\n37:27 Typecheck\n40:48 Conversion Phase\n41:53 Combine\n42:11 Write Interface Files\n43:45 Serialize into DAR\n44:16 Testing\n44:47 Daml Studio / Language Server\n46:40 Questions","channel_name":"Daml","published_at":"2023-02-14T00:00:00.000Z","thumbnail_url":"https://i.ytimg.com/vi/QIHRD45eRHg/hqdefault.jpg","transcript_text":"so yeah let's get started so let's start a bit about taking a step back uh about how we often Define a compiler so what does a compiler actually do so in Computing a compiler is itself a computer program that translates computer code written in often one programming language called The Source language and it translates into another language to target language so take one language speak to another language and of course compiler has to be written into something as well actually quite commonly a good test is if it's written in the source language as well yeah so in the case of damel we have demo source code which are in demo files we have a demo compiler I'll get to where it's written in and it translates to demo LF which are nicely packed up into darkbox um that's nice and simple but it's actually not that simple we expect a bit more from compilers these days so in particular if you have some with all of that is basically the top bit of all the bullet points right so yes we want to translate the source language to a target language but we also want to actually deal with environment in the code which the code will run so what does this mean so for example um with C this often means you know you're actually compiling it to a particular particular architecture and interestingly in our case this architecture is a ledger right so we're trans our Target here our Target environment is a ledger environment and and the choice exercises we can do on them um but also we'd be quite sad if we try to compile a demo program and just sorry did not work all right these days for compilers we expect a little bit more you know like uh actually maybe he made an error here so there's actually quite a lot more involved in the compiler and we want syntax errors you know I did not expect token here we want type errors so the compile needs to understand the type system and we want a bit of documentation around these errors as well so again already a lot more we expect and now another interesting thing is um packages and libraries right like I think a bit before my time it used to be more common to manually link stuff together or even just manually put source code from things you depend on into the same project um nowadays we would like to just you know refer to a library in this case to our demo.yaml file say oh look we're depending on the standard library or depending on some artifacts someone else has created before and want to be able to reuse this so but we don't expect an external program to really deal with this we actually expect a compiler to deal with this so actually our compiler is also something that manages packages and libraries and our finance and standard Library are two good examples and sometimes well we'll actually be surprised if you couldn't run tests either right we don't just want to run the test as a normal program we want to run tests on our program so we need to actually have something that helps a little bit in running tests on our main codes so we'll also have some predominal tests and I think this is a bit more modern as well um is to expose information about the code to other tools so so what what does this mean um you know we're not really writing code in notepad anymore at least not most of us maybe emacs with some syntax highlighting if you're quite the minimalist sure but a lot of people like to have type information about the programs um that they are writing on the go so what a lot of compilers or have started doing or at least write a tip writing separate tooling it's basically something that can look at the code and expose basically some structure of this coyote two other tools which includes demo Studio and and probably one of the things you might have heard of are like Visual Studio code language servers so we'll get to that so there's quite a few things going on as you can see so there's also pieces there's lots and lots and lots to explain and I won't cover everything I will try to go through the critical path and I will very likely skip a little bit towards the end um so it will be a little bit too deep we'll see we'll see what we get so again we have to download source code on the left and then the demo compiler and what does it do well create stamina left packages which kind of like the minimum functionality of compiler error messages and Diagnostics external dependencies it has to know about The Ledger it can log it actually has a connection to demo Studio Etc all right and there's various stages in this as well they'll have to communicate between each of them and I'll try to relate it to back to some of the tools like Studio as I go that's a good question do is it our compiler still do we still use GHC or is it um our own now ah yes so I'll get to that but but we're happy if you yeah so I will get to the duty bit in I think the slide after this that's fine that's fine sorry thanks for asking um so the this is kind of the rough build pipeline so we have damil build uh with or a demos you built I will also get to that as well we the first step is installing dependency so this means like libraries etc etc generating a package database and this basically means you know like the libraries we Define in our download.yaml we kind of need to make them available to our cloud in some sense and this kind of how we initialize a package database then build a guitar the way to read it is depends on the steps to the site right so building a door we need to build dependency model modules but not too dissimilar from the dependencies above then we compile a single module and do this and we do this for loads of the modules and compiling a simple single modules actual GHC comes in and I'll talk a bit more uh next slide about this um and I suppose parsing pre-processing type checking the sugaring and converting core to LF there's lots of Concepts I'm not going to explain them all in this slide but I will try to get to all of them um after this is done um we will try to combine them all into a package provide interface files into there and serialized it all together into a dollar is that interface files as in the new definition of interfaces no no this is a thank you for asking so this is yeah this is this is a bit of a terminology this is a based on the the Haskell terminology of a Haskell interface file which is basically a file which contains the uh kind of a compiled version of the type signatures which are publicly consumable right so you would say in high school exports these functions are available and these types are available these are the kind of things you could find in an interface file um got it it's it's basically so you don't have to have like all the time available to the actual Source cards to be able to link things up okay that is yeah that's a good question thank you it's the interface to the package basically yeah yeah yeah it's free for the package I think that's not a bit with a compiled version of it so I'll come now to GHC so if you look at the compile single module right that's kind of from there that's kind of larger GHC and yes we are still using GDC good question so what what are we using well we're using a fork still of the Glasgow Hospital boiler it's a fixed version I've actually considered whether it's worth updating um not for now there is some work actually which is interesting about structure type errors which might make it worth but for now it doesn't really seem uh worth it to do it so one reason is we don't really use the newest of the newest objc deliberately we're actually disabled some of the language features that are the newest it's going to prevent people from using this kind of stuff together with Tamil yeah what does what does it actually do so GHC stands for the Glasgow classical violence quite old but it's a very solid piece of work with a lot of research and theory behind it so it's probably one of the better documented compilers and you could repeat this which are still like relevant to the actual internal structure um and and it it is doable if you have a decent background in function programming to actually understand the compiler without having worked with it for multiple years okay so what what does GHC do so GC again it's a compiler so it takes source code but what does it produce well it normally produces machine code as the target for optic architecture and and these days you can also produce hello VM but the the very interesting part of the glass class compiler was llbm um low level virtual machine or something like this it's basically yeah it's something you know like how you have to jvm right um llvm is lower and it's it it's basically if you want to have quite efficient machine code but don't want to Target a particular machine got it because one good way of going it's heavily used by the com in the compiler word I mean um like for example even in Banks Goldman created their own language for their SEC DB and that was using llvm yeah fine I get a concept I just haven't heard that term as well yeah that's good that's good so I think the interesting point I I think I suppose to hear right is that while compilers used to be you know we're targeting x86 like a machine architecture right um nowadays it's more common to Target something like llvm to make it basically easier to then via an llvm compiler as you go down to the machine right so you make it easier to write code um but we've done something which is even higher level so Haskell has also something called core and I've put two technical things in here but I've mainly put it in here for a reference so if you're really interested you can have a look at it and you can find some interesting papers about it so basically what will normally happen in a compiler you will start off you know with the actual program which is written in you know syntax if we write it it will turn into an abstract syntax tree so a tree with nodes representing functions and all sorts and it will link variables and stuff but this gets translated further on into a kind of mini functional programming languages it's a quite common thing for compilers in the functional programming world that it gets reduced to a quite basic language so the quite Advanced structures in high school kind of get de-sugared or reduced to a simpler language and and this language is called core and well the way they say this is the small explicitly type variant of system FC which is their own particular version of system F WF Omega actually um so you have something called Baron direct lambdaq yeah there's a lot of here to unpack so it's basically it is a cube incentive multiple functionalities which you can choose to do and the most trivial one starts here and if you add in one axis you can add a one access you get more and more functionality and basically evomega has um type applications um and polymorphism onto Lambda calculus okay and then added to that to get FC is algebraic data types like the whole data thing that has score has so there's quite a lot to unpack but if you're interested in this basically you think a lot of the principles in in a lot of the functional programming communities basically take something very like complex and just reduce it back and explain it mathematically where we are so why this is relevant to us um yeah I'll actually I'll go back so we have less noise so g8c kind of corresponds to the compiled single module but we don't use llvm or the target code it produces we actually stop GHC before that we stop at core so normally GHC would you know take core and then at some point start trying to compile it to an actual machine to be able to run it but we never do that we stop we stock and at that point convert it into a left to make it serializable to them to be able to send to ledgers so we never write code that you can directly write on your machine and this is why we need Speedy The Interpreter that lives on the um participant nodes that can interpret this kind of reduced functional programming language so kind of okay yeah that's essentially our own version of uh kind of llvm in a way that so that it can or different kind of ledgers and if you want to change the underneath thing it doesn't really matter as far as if it's in a left and we can work work with yeah exactly exactly but it's a much more functional programming based one and it's less it's higher level I would say because the the the intent here is not so much to be super efficient there are some of it right we try to choose terms that's it's it's fair one very important thing is to be able to serialize it into products and that's one of the calls as well for that is it viewable in any way or does it just is it yeah yeah I don't think I've got well don't I don't have much in here um there's even a formal specification of Ls yeah so we have a whole file which writes down how we formally go from basically demo to to bet some you know and how operational semantics are as well if you're if you're familiar with that but I don't mean you might be here but when did you ever have like a demo upgrade problem when the LF definitions will change and that's yes that's a breaking change yeah you're right yeah yeah yeah yeah so there's an interesting versioning problem I'll just talk a bit about it now it's not really in the slides but um you've got the demo language which of course can change syntactically then there's the core bit so two and then of course LF and the left being kind of the representation but it has to be versioned as well because we're serializing this and that's what we're sending to um the participant knowledge and what the engine reads right so the compiler team is quite neatly interwoven with the engine team because if we're going to need to represent something which we can't in the current LF we basically need to make sure that the engine can actually interpret it right because we can send them a new structure but if they don't recognize it they can't do anything with it um and therefore lfs versions as well um but you know like that also means that Canton has to be versions We should have to have in a newer upgrade of Canton to have the newer Speedy which can read the newer LF which supports the new demo yeah LF doesn't change that often though that's right isn't it no no and one interesting bit is core has not changed we haven't even changed the chord from GHC that's how good of an obstruction it is um so yeah there are some changes yeah but it it we try not to change it too much and and we do try to keep the idea of having an abstraction um to you know not have to change too much upgradability might have to change a few things done um yeah so this is I won't talk too much for this because I think this is more interesting for my team but in case you're interested in really digging in this is kind of where the steps correspond to in the actual repositories um and here again you can see what Rocky corresponds to GHC and what we hacked in so pre-process we've hacked in in the compulsinger module and configure core to allow and and the parts module type check the sugar is actually still GC all right okay so what do all the bits do so yeah some one hard bit of this there's so much going on so what what what does Damo do actually I don't know how many people are familiar with the demo assistance but there's also the interesting thing of what does Damo do and Damo is normally the damel assistant which it points to then other binaries which include demo C so I think yeah so we don't just have all is not in a way it's not really a single program it's more something that can refer to other programs so damel and then builds refers to the demo C binary which you can see which you could see in the previous slide where that lives somewhere in compiler but there's loads of other things which you can go underneath so this is kind of a nice way of keeping our command line uh demo commands a bit more modular but it it it is good to keep in mind that there's no there's no direct thing that that is demo build it's Damo C which lives somewhere else which it kind of pipes its uh uh comma like command line arguments too Etc oh God and even demo builds itself dispatches to many places including scholar cards of the engines or the SDK all right um okay so this is again a bit technical so we'll go a little bit quicker here um so like I said it it collects relevant arguments so one one interesting thing is it tries to grab it first from the command line then a demo yaml and then you are in from the environment or it's another way of looking at it it tries to grab the arguments from the environment anything that's in a demo yaml overrides everything from the environment everything that's in the command line and it provides the previous two there's another way of looking at it um and one quite nice thing of the demo compiler is if you look at the actual Source codes it is kind of readable and and these steps which are here are in the actual exact build function and you could kind of it it will it won't take you ridiculously long to to create this list from the actual source code but there are a few Concepts here which are interesting so we've got their dependencies back to database which I mentioned before configuration so this means loads of stuff in a in a demo yaml you know like the the left version yeah and stuff like this SDK version initialize done with your ID States so this basically means the stuff that's a bit around the compiler you know like the things for demo Studio the things for it Shake which I'll get to in a minute and then it's building time so any questions before I go to shake it's good it's really interesting yeah there's a lot so Shake um I blame on Neil Mitchell um so new Mitchell when he was a digital asset um he had previously written his own build system called tray so obviously when you're going to write a new compiler you're going to use your own favorite build system uh but it works pretty well it works pretty well so I think one um interesting thing to think about is you know what what does GHC do um when when it wants to uh build a library right so GSC can compile single module but how do we actually build a library and actually cabal is often used for this so that's the first line like the caval's not really part of shakes up so cabal can be used for packaging at Haskell collaboration programs so what we want to have is something that does that as well and this is what I've talked about you know build a package database and things like this retrieved dependencies that's not really something that like that's something that's normally a little bit more around the compiler it's normally not directly in the compiler it's often the external Commander we kind of do it in there um but it does mean we need a bit more stuff and it gets in and it's actually a bit more like a build system rather than a compiler and so using Shake here is actually a pretty decent solution so Shake is the build system that can iteratively discover new rules and find more dependencies so what does this mean we can say basically when our system says we are depending on this library and then that Library says oh I'm depending on that Library Shake allows you to that allows you to basically iteratively discover what dependencies it needs to pull in what it needs to compile and then it goes like Oh actually I need this as well and it starts to do that but it also has caching so it can take this conceptually quite easy approach or just kind of just following the dependencies um but because it caches it rarely it wastes a lot of time doing this uh so this is kind of I suppose the bits that connects a lot of the parts and and again the shade rules are quite nice to read as well um it does give some opaque error messaging as you might have seen like I think if you try to open a file with demo C and it doesn't exist the the error basically Shake leaks a bit and then you'll you'll see an error that's in the shake form rather than a GC form that's kind of one of the reasons cool um so installing dependencies so this is still before we've actually tried to compile any of our own code right this is mainly just to demo yaml stuff so we're still trying to get ready to to actually compile that code um so we're trying to install basically Doris and uh from our dependencies pull them down whatever um copy them into our dependencies we've metadata and again here error handling right so something to not underestimate we need to have these narrow messaging for for people actually using the software so report Miss independencies and it's all stuff like this by using things like shake and GHC like you can say like oh you can write your own pilot with all these error messages it's so much work to do this yourself there's so many bits where you need to provide good information to the user so generated package database so install dependencies initially it perhaps to be so these are almost all functions so if you're curious you can later take these slides as a reference point and dig around a bit um so we'll go too much into this so here it gets a bit more interesting so again we have a build our function right so we're now let's skip to the compile single module so what will happen is you will try to get to demo files and we've got to try and call generate package on each one of them only each individual file and because we are using Shake underneath this is cached so you can be quite naive in just following the dependency right so if we have two files B and C and they both depend on a we're not going to recompile away right well no it's compiled and we'll use the cached results for a etc okay so I've already spoken quite a bit about this but that that's just take a step back and look at it again so what does compilation mean in the context of demo right so we start off with the source code AS text so what we've actually written and this gets parsed into the syntax tree so this can be nodes I mean if you vary an evening three plus four you can parse something into a plus node with a three and a four underneath as it's two children but with source code is you can do a lot more it's often in multiple phases so parsitting really just tries to take the syntax uh type checking there's quite a few more things going on and it's not just type checking normally it you also sort out all your variables and and input references in them um there's GHC core which we've talked about but gc's Intermediate Language and then using our own new uh fancy convert core to our left face or LF conversions file which is which is um which is where it is in the repo we get to download that app any questions about this because I mean that's probably the key slide in a way that's good okay um I'll go a bit quicker again on this because this is quite technical stuff so this is these are all the actual functions um but it is a bit interesting I think to see um where we have stuff and we're ghcs stuff right so the get parts module is a shake rule which goes to a parse module yes a GHC IDE I haven't talked so much about this so there is t-h-e-i-d-e and there is IDE engine and these two nowadays are the hospital language server which allows you to use vs codes but basically a lot of it is making available type information other things to other bits of um either the compiler or the tooling around this and it's basically a reusable way of getting type information Etc um but here is one interesting bit right so we parse the module using GHC find us some basic stuff but now before we allow um uh GHC to completely go ahead we have a demo preprocessor I will I will show you a bit more detail what it exactly means but basically because we have demo or GHC doesn't understand demo so what we have to do is take the demo and make it into a shape of Haskell right so we're rewriting our demo into how school with some extra bits and I'll show you a little bit how it works later then we go back to action GHC stuff because now we're in Haskell land so GTC just happily goes along then we'll end up with GHC core but here we basically try to retrieve and re-understand what was actually demo and what was Norma has called and used that knowledge to go to LF which those stages is the most computationally intense what takes the most time to do good question um I would say like with GT it's normally the target bits but that's that's not in um I'm not fully sure how long the faces are for our compiler I haven't actually tried it on actually yeah parsing shouldn't be that long pre-processing should be quick type checking can take longer um for high school as well um the sugaring should be quick um I don't know how fast the LF conversion is foreign any other questions okay I'll go into a bit more detail as well so parsing um so parsing here means modify the syntax of the card you've written we don't actually and again I think this is kind of Testament to how good GHC is as a compiler uh we don't actually change the syntax tree so what does this mean we have not added new representations of syntax in our compiler we've actually been able to make due mcdo with um Josh Haskell so how well okay we have to basically Mark what we're going to do is we're going to take our demo convert to the house call but use some things within Haskell to say look actually this is a template or actually this is this bookkeeping with with half course aligned which is very powerful so you can do some smart things to basically tell we know this Haskell represents a template we know this Haskell represents a choice and and we can do this while still using legal Haskell which is quite interesting so technically you don't have to write demo you could write the the Haskell we generate if you would really want to I mean don't do that but um and we use type classes and functional dependencies to kind of force this to work um yeah and another thing um certain things like like Primitives so there's some interesting stuff going on right we use GHC core right we don't compile to um like a machine language but what we want to do is so it's it's basically we are doing things like create this fetch this Etc but if you think about how a normal compiler would generate all the instructions for the machine to be run on on how to actually execute this right so otherwise you don't know what to do with it um but interestingly because Speedy The Interpreter living on the participant nodes has its own well will run its own things so rather than trying and generate a whole chunk of a left telling how to interact with the Ledger would just tells Speedy look at this point we're using a create and we literally gave it a magic token saying this is a primitive function which you know what to do with a GHC does not know what to do with and we will keep it in there right so so this is when you see if you've ever seen magic you know someone's car this is why because this kind of magic is compiler doesn't understand it but Speedy does and it will make sense the moment Speedy actually looks at it right so let's let's look at a bit of practicalities here so say we started with a template T if one field being a party p with one choice C so how does this look like in our face when we're parsing so now we're going to try this is our demo and we're going to try and generate Haskell from it and we generate a data so a data type in high school but here so ignore the demo templates for now you can see the T again so T equals t p party so this is an almost direct translation but we use a type class and this is a demo template bit so the the data type it's not called demo template the data type is called t and the demo templates uh arrow means there is a type class constraint on it and this basically allows us later on to see which of these data types have the demo template restriction ah we need to do slump it's something slightly different when we're changing the core to LF so what's a choice so a choice interestingly because it's part of a template kind of takes implicitly a template argument it's quite similar to how you would translate the object-oriented programming to a functional program actually you would normally take the this argument as a function argument so we have a choice an underscore choice on the course T underscore C which takes the template here than the choice C so C what is c c is actually should be something like data C equals c right it's it's a trivial thing um and then we get an update event update so we don't directly get an ins we actually have to update the lecture it's an update if you can obtain monads um I won't go into details of how that works but here again interface we can see one of the interesting translation bits so this is um done using a functional dependency so there's a hap is anyone familiar with functional dependencies in high school no no okay right I'll intuitively explain it so we have basically it's a type inference mechanism which allows you to infer a type without you having to say anything um and basically what we are seeing with the has exercise type class if we have a template T in a choice C int is the is the only type that you will get right so there's a there's some coverage and I don't need to I won't go through it formally but basically if we know we have a template of type t a choice of type c we know that the result type will be end uniquely and this is quite powerful I mean something you can't do in most languages so you hear you're using Haskell to encode a lot of this stuff which you wouldn't be able to encode directly otherwise you would have to manually output type signatures and stuff but we can actually encode it within Haskell itself right we're basically encoding here types of the choices by using Haskell itself while still being within the Haskell lands and here exercise is not something we're going to properly translate into core it's going to be done by NF when it's actually being run on The Ledger okay yeah and I've already said this so the demo templates it basically says that this is a data type which represents a template so later on we can get it back okay and the Primitive will be replaced okay so pre-processing yeah at Prelude interestingly we remove unsupported language extensions so this is what I've talked about as well because like the new high school stuff we try to keep it to a relatively small area so people don't try and hack around um oh yeah our stuff is strict rather than lazy so we strictified as well yeah loads of other loads of other bits I'll try to go a little bit faster here so this is just GHC GHC type checks everything but since we're in Haskell lab now it's just general type checking as you see we'll do it uh but there is some interesting stuff here now right so we've taken our demo code we're now in high school lands but we've got demo code which is represented using some particular High School staff um but if we now throw errors the user will get Haskell Wireless that's pretty terrible isn't it yeah so there's actually where Dylan has done lots and lots of work and hope and we're actually planning to um have a bit more documentation on this as well so basically didn't have a lot of infrastructure work on the time Checker to make it easier to get errors which are not good for users and make them more demo specific um so I'm like here I think our team is happy to take feedback as well you know so for example normally if you would say five equals to five you get like a quite you know like standard GC error saying intent string as types don't match because it actually equals in house class staff at the same types um so if mismatch similarly for exercise choice T we know that has to be an INT as I talked about through the functional dependency um that's not the string um so again a mismatch but this now means that let's go back a bit the user will go back an error which has this whole has exercise and t and c and ends and might mention a type class and now they go like I haven't written has exercise so you need to be a bit smarter so the hash choice is wrong it should be as exercise um and what we do basically GT is also quite flexible if it's error messages and like in a like how you program it in GHC and you can actually say for this type class when we get an error um actually say something else so we don't just say you know has exercise doesn't have an instance for TC and this time here or the constraints here don't match or something the user will have no clue about we instead say the choice is expecting this certain type uh for this particular template and this this error is handwritten by us um but interestingly because GHC is quite easy to modify it's not that deep into the code um we've tried to make it a bit easier to add new stuff so yeah custom errors um but yeah the problem is yeah okay oh I've got too much into this detail stuff um yeah so the the the the thing here is always it's about constraints type constraints seeing where they come from trying to get information of like you know what bit of demo did it refer to that's why we use the dowel uh interfaces sorry not the double interface the Haskell interfaces to say you know like double this was a template this was a choice Etc uh and then change it okay we'll just rush a bit through this um let's see type checking it's not too interesting here is where it's more interesting so conversion so we've gone through jdc we have core um this core has just Haskell but has Type classes of high school which we know the meaning of and GHC does not right we know that demo template as a type class kind of secretly means this was originally a demo template so the moment we've now gone to or actually time where we want to convert core to a left we can remember this information because it will be in the type and then we can do something slightly smarter just for this and get back our stuff yeah but again like I said the interesting bit is we have not adapted to GHC core right okay um yeah so try to combine it all again and this is kind of like how you might roughly send it over and I think let's see this is a little bit this is gonna get okay so yes we've done the single compile single module stuff all demo left and then we combine this into a single dollar that's kind of where it ends up running away from the end thank you interface files are very similar to Haskell interfaces don't know exactly what is in there um but the trick is it's used for incremental compilation right so the idea is we don't we we can just use look like a like the answer uh answer the Ian's question it has representations of the types in a kind of compiled form which you can refer to so as long as we know that the source file hasn't changed we can just look at the interface file rather than recompile the whole thing again um and that's why are those those are the dot the different extensions that you see inside a package you've got like the yeah the H is it hia or something yeah yeah yeah yeah yeah yeah yeah yeah exactly exactly because you don't have to have those right um I'm not fully sure if you don't have yeah I mean if you have to you you might need them if you don't have the original them all right um but I'm not sure about this because I couldn't see the documentation what those thoughts because I was looking inside the package tonight I couldn't see what these files were for so this is interesting to know okay okay what does hia stat is hia isn't it so I think it's ah I know H I would just have to worry yeah it's always High School interface okay got it um I always like object um and I think there's some a file so there's also the seven libraries as well and this is the function which actually serializes the whole thing um interesting bits I suppose just a domino left the dependencies the directory or the module dependencies oh yeah everybody spoke yeah I don't really have time to do that but it's also data dependencies right so the source dependencies there's also data dependencies where you just refer to the dart we support that as well but the semantics of that are a bit tricky oh yeah near the interface of us so yeah I'll go a bit quicker for this folks I I have less knowledge to chance as well so here testing which I've already gone through larger mostly of that so but there's some interesting bits about dlf so we can actually extract test names back from the produced LF um yeah let's go for this so yeah so maybe just to give a bit more info so here yeah I've kind of been kind of wondering what something's what to do so basically what has happened is we've done a lot of work previously as a team to develop things like GNC ID which allows us to basically have the whole damage to your thing which gives you type information Etc but this is kind of Open Source externally evolved into the Haskell language server um which works with PS codes so but now kind of the well while with GHC we're stuck in an old version but fine you know it's more obvious how to shift here the the world has changed more underneath of us so it's a bit of an interesting problem here as well well so so you mean comparing the Haskell um so language server compared to the download language search yeah so the stock we use is basically ask a language server like we okay yes we're stuck in an old version of Haskell language so yes yeah we're basically using this stuff rewrite and open sourced and and the community and right but then within demo Studio we have some stuff which allows you to again make it that more specific right yeah that's kind of the right so it's quite a good design in the sense that most of our stuff is still for Haskell and we try to not change things too much so we can kind of stay within hospital and and keep the updates but now because ghcid has changed quite a lot it's a little bit harder we'll have to see about what to do there but um um yeah okay I think that's fine cool thank you thank you bass that was really interesting and certainly helped my get a lot straighter in my head the relationship between damel and Haskell in particular yeah it's I think it's a Testament of the Haskell language and the GDC compiler the fact that we're able to do a lot of this without a ridiculous amount of pain um I would say but it has its downsides of course that the the haskellisms and the ghcisms kind of leak through to the user sometimes and that is something my team tries to actively tackle like I said with the type errors Dylan has been working on and it's something we also have to take feedback on because it is something we're still planning work for the next half Year again to improve type errors and document a bit more about so any feedback on this is more than welcome sure well no thank you this was great it reminds me some really old errors and challenges and when Neil was here the discussions we had okay cool brought back some old memories what's your sort of primary things that you're focusing on now in in the team to improve so okay so it didn't it's going to continue with a lot of improvements in the IDE and anti-bearers but one of the main things is going to be upgrades so um the the biggest feature is we're going to look at how to have a quite minimal version of upgrades a proof of Concepts sorry do you mean upgrading upgrading and upgrading the customer's code or do you mean upgrading as an upgrading um to a new version of SDK or do you mean upgrading customer code yeah yeah right so like for example adding a field through your template or something yeah or updating a choice um like the the body right uh and we're gonna have quite restricted version of that at first but that's that's one thing we want to work we're planning to work on first um yeah and one of the main things we're going to support hopefully work on first is how to look at um the whole package management story of this and how to do this and cancel all the package fitting and kind of do that in a nice way and only then look a bit more on what actually a sport than language so we're basically going to try and get most of the mechanics in and and and let customers be able to do it and then follow on on how to actually think more about where to allow flexibility and why not um it's a tricky problem right cool okay I think there are more questions about us so say thank you very much again I will be sharing this with the wider TSC team as well so um in conclusion thank you very much for time it's been a really good session I've certainly really enjoyed that and learned a lot so thank you okay yeah and thanks for asking me as well um please do share the video with me as well and I'd love to think yeah yeah and then if you want to chat wider as well of course you can all right great well thank you for watching","transcript_synced_at":"2026-10-26T04:08:26.827Z","segments":[{"start_seconds":0,"text":"so yeah let's get started so let's start a bit about taking a step back uh about how we often Define a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=0s"},{"start_seconds":8,"text":"compiler so what does a compiler actually do so in Computing a compiler is itself a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=8s"},{"start_seconds":16,"text":"computer program that translates computer code written in often one programming language called The Source language and it translates into another","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=16s"},{"start_seconds":25,"text":"language to target language so take one language speak to another language and of course compiler has to be written into something as well actually quite","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=25s"},{"start_seconds":33,"text":"commonly a good test is if it's written in the source language as well yeah so in the case of damel we have","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=33s"},{"start_seconds":41,"text":"demo source code which are in demo files we have a demo compiler I'll get to where it's written in and it translates","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=41s"},{"start_seconds":49,"text":"to demo LF which are nicely packed up into darkbox um","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=49s"},{"start_seconds":58,"text":"that's nice and simple but it's actually not that simple we expect a bit more from compilers these days","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=58s"},{"start_seconds":65,"text":"so in particular if you have some with all of that is basically the top bit of all the bullet points right so yes we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=65s"},{"start_seconds":74,"text":"want to translate the source language to a target language but we also want to actually deal with environment in the code which the code","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=74s"},{"start_seconds":82,"text":"will run so what does this mean so for example um with C this often means you know you're actually compiling it to a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=82s"},{"start_seconds":90,"text":"particular particular architecture and interestingly in our case this architecture is a ledger right so we're","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=90s"},{"start_seconds":97,"text":"trans our Target here our Target environment is a ledger environment and and the choice exercises we can do on","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=97s"},{"start_seconds":105,"text":"them um but also we'd be quite sad if we try to compile a demo program and just sorry","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=105s"},{"start_seconds":114,"text":"did not work all right these days for compilers we expect a little bit more you know like uh actually maybe he made","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=114s"},{"start_seconds":122,"text":"an error here so there's actually quite a lot more involved in the compiler and we want syntax errors you know I did not","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=122s"},{"start_seconds":128,"text":"expect token here we want type errors so the compile needs to understand the type system and we want a bit of","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=128s"},{"start_seconds":136,"text":"documentation around these errors as well so again already a lot more we expect and now another interesting thing is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=136s"},{"start_seconds":145,"text":"um packages and libraries right like I think a bit before my time it used to be more common to manually link stuff","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=145s"},{"start_seconds":153,"text":"together or even just manually put source code from things you depend on into the same project","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=153s"},{"start_seconds":160,"text":"um nowadays we would like to just you know refer to a library in this case to our demo.yaml file say oh look we're depending on the standard library or","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=160s"},{"start_seconds":168,"text":"depending on some artifacts someone else has created before and want to be able to reuse this so but we don't expect an external program","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=168s"},{"start_seconds":177,"text":"to really deal with this we actually expect a compiler to deal with this so actually our compiler is also something that manages packages and libraries","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=177s"},{"start_seconds":185,"text":"and our finance and standard Library are two good examples and sometimes well we'll actually be","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=185s"},{"start_seconds":193,"text":"surprised if you couldn't run tests either right we don't just want to run the test as a normal program we want to run tests on our program so we need to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=193s"},{"start_seconds":202,"text":"actually have something that helps a little bit in running tests on our main codes so we'll also have some predominal tests","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=202s"},{"start_seconds":209,"text":"and I think this is a bit more modern as well um is to expose information about the code to other tools so so what what does","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=209s"},{"start_seconds":218,"text":"this mean um you know we're not really writing code in notepad anymore at least not most of us maybe emacs with","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=218s"},{"start_seconds":226,"text":"some syntax highlighting if you're quite the minimalist sure but a lot of people like to have type information about the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=226s"},{"start_seconds":233,"text":"programs um that they are writing on the go so what a lot of compilers or have started","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=233s"},{"start_seconds":241,"text":"doing or at least write a tip writing separate tooling it's basically something that can look at the code and expose","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=241s"},{"start_seconds":249,"text":"basically some structure of this coyote two other tools which includes demo Studio and and probably one of the things you","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=249s"},{"start_seconds":257,"text":"might have heard of are like Visual Studio code language servers so we'll get to that so there's quite a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=257s"},{"start_seconds":265,"text":"few things going on as you can see so there's also pieces there's lots and lots and lots to explain and I won't","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=265s"},{"start_seconds":272,"text":"cover everything I will try to go through the critical path and I will very likely skip a little bit towards the end um so it will be a little bit too deep","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=272s"},{"start_seconds":280,"text":"we'll see we'll see what we get so again we have to download source code on the left and then the demo compiler and what does it do well create stamina","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=280s"},{"start_seconds":289,"text":"left packages which kind of like the minimum functionality of compiler error messages and Diagnostics external dependencies it has to know about The Ledger","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=289s"},{"start_seconds":298,"text":"it can log it actually has a connection to demo Studio Etc all right and there's various stages in this as","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=298s"},{"start_seconds":305,"text":"well they'll have to communicate between each of them and I'll try to relate it to back to some of the tools like Studio as I go","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=305s"},{"start_seconds":313,"text":"that's a good question do is it our compiler still do we still use GHC or is it um our own now ah yes so I'll get to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=313s"},{"start_seconds":322,"text":"that but but we're happy if you yeah so I will get to the duty bit","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=322s"},{"start_seconds":330,"text":"in I think the slide after this that's fine that's fine sorry","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=330s"},{"start_seconds":336,"text":"thanks for asking um so the this is kind of the rough build pipeline so we have","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=336s"},{"start_seconds":344,"text":"damil build uh with or a demos you built I will also get to that as well we the first step is installing dependency so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=344s"},{"start_seconds":353,"text":"this means like libraries etc etc generating a package database and this basically means you know like the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=353s"},{"start_seconds":361,"text":"libraries we Define in our download.yaml we kind of need to make them available to our cloud in some sense and this kind of how we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=361s"},{"start_seconds":369,"text":"initialize a package database then build a guitar the way to read it is depends on the steps to the site right so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=369s"},{"start_seconds":377,"text":"building a door we need to build dependency model modules but not too dissimilar from the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=377s"},{"start_seconds":383,"text":"dependencies above then we compile a single module and do this and we do this for loads of the modules","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=383s"},{"start_seconds":391,"text":"and compiling a simple single modules actual GHC comes in and I'll talk a bit more uh next slide about this","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=391s"},{"start_seconds":399,"text":"um and I suppose parsing pre-processing type checking the sugaring and converting core to LF there's lots of","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=399s"},{"start_seconds":407,"text":"Concepts I'm not going to explain them all in this slide but I will try to get to all of them um after this is done um we will try to combine them all into","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=407s"},{"start_seconds":415,"text":"a package provide interface files into there and serialized it all together into a dollar","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=415s"},{"start_seconds":422,"text":"is that interface files as in the new definition of interfaces no no this is a thank you for asking so this is yeah this is this is a bit of a terminology","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=422s"},{"start_seconds":431,"text":"this is a based on the the Haskell terminology of a Haskell interface file which is basically a file which contains","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=431s"},{"start_seconds":439,"text":"the uh kind of a compiled version of the type signatures which are publicly consumable right so you would say in","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=439s"},{"start_seconds":448,"text":"high school exports these functions are available and these types are available these are the kind of things you could find in an interface file","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=448s"},{"start_seconds":456,"text":"um got it it's it's basically so you don't have to have like all the time available to the actual Source cards to be able to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=456s"},{"start_seconds":464,"text":"link things up okay that is yeah that's a good question thank you it's the interface to the package basically","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=464s"},{"start_seconds":472,"text":"yeah yeah yeah it's free for the package I think that's not a bit with a compiled version of it so I'll come now to GHC so if you look at the compile single module","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=472s"},{"start_seconds":481,"text":"right that's kind of from there that's kind of larger GHC and yes we are still using GDC good question so what what are we using well we're using","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=481s"},{"start_seconds":489,"text":"a fork still of the Glasgow Hospital boiler it's a fixed version","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=489s"},{"start_seconds":498,"text":"I've actually considered whether it's worth updating um not for now there is some work actually which is interesting about","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=498s"},{"start_seconds":505,"text":"structure type errors which might make it worth but for now it doesn't really seem uh worth it to do it so one reason is we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=505s"},{"start_seconds":513,"text":"don't really use the newest of the newest objc deliberately we're actually disabled some of the language features","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=513s"},{"start_seconds":520,"text":"that are the newest it's going to prevent people from using this kind of stuff together with Tamil yeah what does what does it actually do so GHC stands","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=520s"},{"start_seconds":528,"text":"for the Glasgow classical violence quite old but it's a very solid piece of work with a lot of research and theory behind","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=528s"},{"start_seconds":536,"text":"it so it's probably one of the better documented compilers and you could repeat this which are still like","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=536s"},{"start_seconds":544,"text":"relevant to the actual internal structure um and and it it is doable if you have a decent","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=544s"},{"start_seconds":553,"text":"background in function programming to actually understand the compiler without having worked with it for multiple years okay so what what does GHC do so GC","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=553s"},{"start_seconds":561,"text":"again it's a compiler so it takes source code but what does it produce well it normally produces machine code as the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=561s"},{"start_seconds":568,"text":"target for optic architecture and and these days you can also produce hello VM but the the very interesting part of the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=568s"},{"start_seconds":577,"text":"glass class compiler was llbm um low level virtual machine or something like this it's basically yeah","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=577s"},{"start_seconds":584,"text":"it's something you know like how you have to jvm right um llvm is lower and it's it it's","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=584s"},{"start_seconds":593,"text":"basically if you want to have quite efficient machine code but don't want to Target a particular machine got it because one","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=593s"},{"start_seconds":600,"text":"good way of going it's heavily used by the com in the compiler word I mean um like for example even in Banks Goldman created their own language for their SEC","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=600s"},{"start_seconds":609,"text":"DB and that was using llvm yeah fine I get a concept I just haven't heard","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=609s"},{"start_seconds":616,"text":"that term as well yeah that's good that's good so I think the interesting point I I think I suppose to hear right is that while compilers used to be you","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=616s"},{"start_seconds":625,"text":"know we're targeting x86 like a machine architecture right um nowadays it's more common to Target","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=625s"},{"start_seconds":632,"text":"something like llvm to make it basically easier to then via an llvm compiler as you go down to the machine right so you","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=632s"},{"start_seconds":640,"text":"make it easier to write code um but we've done something which is even higher level so Haskell has also something called core","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=640s"},{"start_seconds":648,"text":"and I've put two technical things in here but I've mainly put it in here for a reference so if you're really interested you can have a look at it and","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=648s"},{"start_seconds":656,"text":"you can find some interesting papers about it so basically what will normally happen in a compiler you will start off you know with the actual program which is written in you know syntax if we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=656s"},{"start_seconds":665,"text":"write it it will turn into an abstract syntax tree so a tree with nodes representing functions and all sorts and","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=665s"},{"start_seconds":671,"text":"it will link variables and stuff but this gets translated further on into a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=671s"},{"start_seconds":679,"text":"kind of mini functional programming languages it's a quite common thing for compilers in the functional programming world that it gets reduced to a quite","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=679s"},{"start_seconds":689,"text":"basic language so the quite Advanced structures in high school kind of get de-sugared or reduced to a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=689s"},{"start_seconds":696,"text":"simpler language and and this language is called core and well the way they say this is the small explicitly type variant of system","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=696s"},{"start_seconds":705,"text":"FC which is their own particular version of system F WF Omega actually","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=705s"},{"start_seconds":713,"text":"um so you have something called Baron direct lambdaq yeah there's a lot of here to unpack so it's basically it is a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=713s"},{"start_seconds":721,"text":"cube incentive multiple functionalities which you can choose to do and the most trivial one starts here","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=721s"},{"start_seconds":729,"text":"and if you add in one axis you can add a one access you get more and more functionality and basically evomega has","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=729s"},{"start_seconds":737,"text":"um type applications um and polymorphism onto Lambda calculus","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=737s"},{"start_seconds":746,"text":"okay and then added to that to get FC is algebraic data types like","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=746s"},{"start_seconds":754,"text":"the whole data thing that has score has so there's quite a lot to unpack but if you're interested in this basically you","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=754s"},{"start_seconds":761,"text":"think a lot of the principles in in a lot of the functional programming communities basically take something very like complex and just reduce it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=761s"},{"start_seconds":768,"text":"back and explain it mathematically where we are so why this is relevant to us um yeah I'll actually I'll go back so we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=768s"},{"start_seconds":777,"text":"have less noise so g8c kind of corresponds to the compiled single module but we don't use llvm or","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=777s"},{"start_seconds":787,"text":"the target code it produces we actually stop GHC before that we stop at core so normally GHC would you know take core","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=787s"},{"start_seconds":795,"text":"and then at some point start trying to compile it to an actual machine to be able to run it but we never do that we stop","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=795s"},{"start_seconds":802,"text":"we stock and at that point convert it into a left to make it serializable to them to be able to send to ledgers so we never","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=802s"},{"start_seconds":810,"text":"write code that you can directly write on your machine and this is why we need Speedy The Interpreter that lives on the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=810s"},{"start_seconds":818,"text":"um participant nodes that can interpret this kind of reduced","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=818s"},{"start_seconds":825,"text":"functional programming language so kind of okay","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=825s"},{"start_seconds":832,"text":"yeah that's essentially our own version of uh kind of llvm in a way that so that it can or different kind of ledgers and","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=832s"},{"start_seconds":840,"text":"if you want to change the underneath thing it doesn't really matter as far as if it's in a left and we can work work with yeah exactly exactly but it's a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=840s"},{"start_seconds":848,"text":"much more functional programming based one and it's less it's higher level I would say because the the the intent here is not","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=848s"},{"start_seconds":857,"text":"so much to be super efficient there are some of it right we try to choose terms that's it's it's fair one very important thing is to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=857s"},{"start_seconds":866,"text":"be able to serialize it into products and that's one of the calls as well for that is it viewable in any way or does it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=866s"},{"start_seconds":874,"text":"just is it yeah yeah I don't think I've got well don't I don't have much in here um there's even a formal specification","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=874s"},{"start_seconds":883,"text":"of Ls yeah so we have a whole file which writes down how we formally go from","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=883s"},{"start_seconds":891,"text":"basically demo to to bet some you know and how operational semantics are as well if you're if you're familiar with","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=891s"},{"start_seconds":899,"text":"that but I don't mean you might be here but when did you ever have like a demo upgrade problem when the LF definitions","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=899s"},{"start_seconds":908,"text":"will change and that's yes that's a breaking change yeah you're right yeah yeah yeah yeah so there's an interesting versioning problem I'll just talk a bit","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=908s"},{"start_seconds":916,"text":"about it now it's not really in the slides but um you've got the demo language which of course can change syntactically","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=916s"},{"start_seconds":923,"text":"then there's the core bit so two and then of course LF and the left being","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=923s"},{"start_seconds":931,"text":"kind of the representation but it has to be versioned as well because we're serializing this and that's what we're sending to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=931s"},{"start_seconds":938,"text":"um the participant knowledge and what the engine reads right so the compiler team is quite neatly interwoven with the engine team because if we're going to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=938s"},{"start_seconds":947,"text":"need to represent something which we can't in the current LF we basically need to make sure that the engine can actually interpret it right because we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=947s"},{"start_seconds":954,"text":"can send them a new structure but if they don't recognize it they can't do anything with it um and therefore lfs versions as well","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=954s"},{"start_seconds":963,"text":"um but you know like that also means that Canton has to be versions We should have to have in a newer upgrade of Canton to have the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=963s"},{"start_seconds":972,"text":"newer Speedy which can read the newer LF which supports the new demo yeah LF doesn't change that often though","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=972s"},{"start_seconds":981,"text":"that's right isn't it no no and one interesting bit is core has not changed we haven't even changed the chord from GHC that's how good of an obstruction it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=981s"},{"start_seconds":989,"text":"is um so yeah there are some changes yeah","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=989s"},{"start_seconds":997,"text":"but it it we try not to change it too much and and we do try to keep the idea of having an abstraction","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=997s"},{"start_seconds":1004,"text":"um to you know not have to change too much upgradability might have to change a few things done","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1004s"},{"start_seconds":1014,"text":"um yeah so this is I won't talk too much for this because I think this is more interesting for my team but in case you're interested in really digging in this is kind of where the steps","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1014s"},{"start_seconds":1021,"text":"correspond to in the actual repositories um and here again you can see what Rocky","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1021s"},{"start_seconds":1029,"text":"corresponds to GHC and what we hacked in so pre-process we've hacked in in the compulsinger module","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1029s"},{"start_seconds":1037,"text":"and configure core to allow and and the parts module type check the sugar is actually still GC","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1037s"},{"start_seconds":1045,"text":"all right okay so what do all the bits do so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1045s"},{"start_seconds":1054,"text":"yeah some one hard bit of this there's so much going on so what what what does Damo do actually I don't know how many people are familiar","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1054s"},{"start_seconds":1063,"text":"with the demo assistance but there's also the interesting thing of what does Damo do and Damo is normally the damel assistant","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1063s"},{"start_seconds":1070,"text":"which it points to then other binaries which include demo C so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1070s"},{"start_seconds":1077,"text":"I think yeah so we don't just have all is not in a way it's not really a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1077s"},{"start_seconds":1085,"text":"single program it's more something that can refer to other programs so damel and then builds refers to the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1085s"},{"start_seconds":1095,"text":"demo C binary which you can see which you could see in the previous slide where that lives somewhere in compiler but there's loads","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1095s"},{"start_seconds":1103,"text":"of other things which you can go underneath so this is kind of a nice way of keeping our command line","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1103s"},{"start_seconds":1110,"text":"uh demo commands a bit more modular but it it it is good to keep in mind","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1110s"},{"start_seconds":1117,"text":"that there's no there's no direct thing that that is demo build it's Damo C which lives somewhere else which it kind","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1117s"},{"start_seconds":1125,"text":"of pipes its uh uh comma like command line arguments too Etc","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1125s"},{"start_seconds":1133,"text":"oh God and even demo builds itself dispatches to many places","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1133s"},{"start_seconds":1140,"text":"including scholar cards of the engines or the SDK","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1140s"},{"start_seconds":1147,"text":"all right um okay so this is again a bit technical so we'll go a little bit quicker here","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1147s"},{"start_seconds":1155,"text":"um so like I said it it collects relevant arguments so one one interesting thing is it tries to grab it first from the command line then a demo","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1155s"},{"start_seconds":1163,"text":"yaml and then you are in from the environment or it's another way of looking at it it tries to grab the arguments from the environment anything that's in a demo","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1163s"},{"start_seconds":1172,"text":"yaml overrides everything from the environment everything that's in the command line and it provides the previous two there's another way of looking at it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1172s"},{"start_seconds":1179,"text":"um and one quite nice thing of the demo compiler is if you look at the actual Source codes it is kind of readable and","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1179s"},{"start_seconds":1187,"text":"and these steps which are here are in the actual exact build function and you could kind of it it will it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1187s"},{"start_seconds":1194,"text":"won't take you ridiculously long to to create this list from the actual source code but there are a few Concepts here which are interesting so we've got their","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1194s"},{"start_seconds":1204,"text":"dependencies back to database which I mentioned before configuration so this means loads of stuff in a in a demo yaml you know like","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1204s"},{"start_seconds":1212,"text":"the the left version yeah and stuff like this SDK version initialize done with your ID States","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1212s"},{"start_seconds":1220,"text":"so this basically means the stuff that's a bit around the compiler you know like the things for demo Studio the things","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1220s"},{"start_seconds":1228,"text":"for it Shake which I'll get to in a minute and then it's building time so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1228s"},{"start_seconds":1235,"text":"any questions before I go to shake it's good it's really interesting yeah","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1235s"},{"start_seconds":1245,"text":"there's a lot so Shake um I blame on Neil Mitchell um so new Mitchell when he was a digital","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1245s"},{"start_seconds":1252,"text":"asset um he had previously written his own build system called tray so obviously when you're going to write a new compiler you're going to use your","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1252s"},{"start_seconds":1261,"text":"own favorite build system uh but it works pretty well it works pretty well so I think one um","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1261s"},{"start_seconds":1269,"text":"interesting thing to think about is you know what what does GHC do um when","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1269s"},{"start_seconds":1276,"text":"when it wants to uh build a library right so GSC can compile single module but how do we actually build a library","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1276s"},{"start_seconds":1283,"text":"and actually cabal is often used for this so that's the first line like the caval's not really part of shakes up so cabal can be used for packaging at","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1283s"},{"start_seconds":1291,"text":"Haskell collaboration programs so what we want to have is something that does that as well and this is what I've talked about you know build a package database and things","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1291s"},{"start_seconds":1300,"text":"like this retrieved dependencies that's not really something that like that's something that's normally a little bit more around the compiler it's normally not directly in the compiler it's often","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1300s"},{"start_seconds":1309,"text":"the external Commander we kind of do it in there um but it does mean we need a bit more stuff and it gets in and it's actually a bit","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1309s"},{"start_seconds":1317,"text":"more like a build system rather than a compiler and so using Shake here is actually a pretty decent solution so Shake is the build system that can","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1317s"},{"start_seconds":1326,"text":"iteratively discover new rules and find more dependencies so what does this mean we can say basically when our system","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1326s"},{"start_seconds":1334,"text":"says we are depending on this library and then that Library says oh I'm depending on that Library Shake allows you to that allows you to basically","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1334s"},{"start_seconds":1341,"text":"iteratively discover what dependencies it needs to pull in what it needs to compile and then it goes like Oh actually I need","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1341s"},{"start_seconds":1350,"text":"this as well and it starts to do that but it also has caching so it can take this conceptually quite easy approach or","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1350s"},{"start_seconds":1358,"text":"just kind of just following the dependencies um but because it caches it rarely it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1358s"},{"start_seconds":1365,"text":"wastes a lot of time doing this uh so this is kind of I suppose the bits that connects a lot","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1365s"},{"start_seconds":1374,"text":"of the parts and and again the shade rules are quite nice to read as well um it does give some opaque error","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1374s"},{"start_seconds":1381,"text":"messaging as you might have seen like I think if you try to open a file with demo C and it doesn't exist the the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1381s"},{"start_seconds":1389,"text":"error basically Shake leaks a bit and then you'll you'll see an error that's in the shake form rather than a GC form","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1389s"},{"start_seconds":1396,"text":"that's kind of one of the reasons cool um so installing dependencies so this is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1396s"},{"start_seconds":1405,"text":"still before we've actually tried to compile any of our own code right this is mainly just to demo yaml stuff","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1405s"},{"start_seconds":1412,"text":"so we're still trying to get ready to to actually compile that code um so we're trying to install basically","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1412s"},{"start_seconds":1419,"text":"Doris and uh from our dependencies pull them down whatever um copy them into our dependencies we've","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1419s"},{"start_seconds":1427,"text":"metadata and again here error handling right so something to not underestimate we need to have these narrow messaging","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1427s"},{"start_seconds":1434,"text":"for for people actually using the software so report Miss independencies and it's all stuff like this by using","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1434s"},{"start_seconds":1443,"text":"things like shake and GHC like you can say like oh you can write your own pilot with all these error messages it's so much work to do this yourself there's so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1443s"},{"start_seconds":1451,"text":"many bits where you need to provide good information to the user so generated package database so install dependencies initially it perhaps to be","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1451s"},{"start_seconds":1460,"text":"so these are almost all functions so if you're curious you can later take these slides as a reference point and dig around a bit","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1460s"},{"start_seconds":1467,"text":"um so we'll go too much into this so here it gets a bit more interesting so again we have a build our function","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1467s"},{"start_seconds":1477,"text":"right so we're now let's skip to the compile single module so what will happen is you will try to get to demo","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1477s"},{"start_seconds":1484,"text":"files and we've got to try and call generate package on each one of them only each individual file and because we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1484s"},{"start_seconds":1492,"text":"are using Shake underneath this is cached so you can be quite naive in just following the dependency right","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1492s"},{"start_seconds":1500,"text":"so if we have two files B and C and they both depend on a we're not going to recompile away right","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1500s"},{"start_seconds":1507,"text":"well no it's compiled and we'll use the cached results for a etc okay","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1507s"},{"start_seconds":1517,"text":"so I've already spoken quite a bit about this but that that's just take a step back and look at it again so what does compilation mean in the context of demo","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1517s"},{"start_seconds":1526,"text":"right so we start off with the source code AS text so what we've actually written","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1526s"},{"start_seconds":1534,"text":"and this gets parsed into the syntax tree so this can be nodes I mean if you vary an evening three plus four you can parse","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1534s"},{"start_seconds":1542,"text":"something into a plus node with a three and a four underneath as it's two children but with source code is you can do a lot","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1542s"},{"start_seconds":1550,"text":"more it's often in multiple phases so parsitting really just tries to take the syntax uh type checking there's quite a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1550s"},{"start_seconds":1558,"text":"few more things going on and it's not just type checking normally it you also sort out all your variables","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1558s"},{"start_seconds":1565,"text":"and and input references in them um there's GHC core which we've talked about but gc's Intermediate Language and","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1565s"},{"start_seconds":1575,"text":"then using our own new uh fancy convert core to our left face or LF conversions file which is which is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1575s"},{"start_seconds":1583,"text":"um which is where it is in the repo we get to download that app any questions about this because I mean","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1583s"},{"start_seconds":1591,"text":"that's probably the key slide in a way that's good","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1591s"},{"start_seconds":1601,"text":"okay um I'll go a bit quicker again on this because this is quite technical stuff so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1601s"},{"start_seconds":1609,"text":"this is these are all the actual functions um but it is a bit interesting I think to see um where we have stuff","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1609s"},{"start_seconds":1616,"text":"and we're ghcs stuff right so the get parts module is a shake rule which goes","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1616s"},{"start_seconds":1623,"text":"to a parse module yes a GHC IDE I haven't talked so much about this so there is t-h-e-i-d-e and there is IDE","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1623s"},{"start_seconds":1633,"text":"engine and these two nowadays are the hospital language server which allows you to use","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1633s"},{"start_seconds":1640,"text":"vs codes but basically a lot of it is making available type information other things to other bits of","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1640s"},{"start_seconds":1649,"text":"um either the compiler or the tooling around this and it's basically a reusable way of getting type information","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1649s"},{"start_seconds":1656,"text":"Etc um but here is one interesting bit right so we parse the module using GHC find us","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1656s"},{"start_seconds":1662,"text":"some basic stuff but now before we allow um uh GHC to completely go ahead we have a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1662s"},{"start_seconds":1671,"text":"demo preprocessor I will I will show you a bit more detail what it exactly means but basically because we have demo or GHC doesn't","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1671s"},{"start_seconds":1680,"text":"understand demo so what we have to do is take the demo and make it into a shape of Haskell","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1680s"},{"start_seconds":1688,"text":"right so we're rewriting our demo into how school with some extra bits and I'll show you a little bit how it works later","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1688s"},{"start_seconds":1696,"text":"then we go back to action GHC stuff because now we're in Haskell land so GTC just happily goes along then we'll end","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1696s"},{"start_seconds":1704,"text":"up with GHC core but here we basically try to retrieve and re-understand","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1704s"},{"start_seconds":1712,"text":"what was actually demo and what was Norma has called and used that knowledge to go to LF","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1712s"},{"start_seconds":1721,"text":"which those stages is the most computationally intense what takes the most time to do","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1721s"},{"start_seconds":1729,"text":"good question um I would say like with GT it's normally","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1729s"},{"start_seconds":1740,"text":"the target bits but that's that's not in um I'm not fully sure how long the faces","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1740s"},{"start_seconds":1747,"text":"are for our compiler I haven't actually tried it on actually yeah parsing shouldn't be that long pre-processing should be quick","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1747s"},{"start_seconds":1755,"text":"type checking can take longer um for high school as well um the sugaring should be quick um I don't know how fast the LF","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1755s"},{"start_seconds":1764,"text":"conversion is foreign any other questions","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1764s"},{"start_seconds":1776,"text":"okay I'll go into a bit more detail as well so parsing um so parsing here means","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1776s"},{"start_seconds":1785,"text":"modify the syntax of the card you've written we don't actually and again I think this is kind","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1785s"},{"start_seconds":1793,"text":"of Testament to how good GHC is as a compiler uh we don't actually change the syntax tree","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1793s"},{"start_seconds":1799,"text":"so what does this mean we have not added new representations of syntax in our","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1799s"},{"start_seconds":1807,"text":"compiler we've actually been able to make due mcdo with um Josh Haskell","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1807s"},{"start_seconds":1815,"text":"so how well okay we have to basically Mark what we're going to do is we're going to take our demo convert to the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1815s"},{"start_seconds":1822,"text":"house call but use some things within Haskell to say look actually this is a template or actually this is this bookkeeping with with half course","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1822s"},{"start_seconds":1830,"text":"aligned which is very powerful so you can do some smart things to basically tell we know this Haskell represents a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1830s"},{"start_seconds":1840,"text":"template we know this Haskell represents a choice and and we can do this while still using legal Haskell which is quite interesting","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1840s"},{"start_seconds":1848,"text":"so technically you don't have to write demo you could write the the Haskell we generate if you would really want to I mean don't","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1848s"},{"start_seconds":1855,"text":"do that but um and we use type classes and functional dependencies to kind of force this to work","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1855s"},{"start_seconds":1862,"text":"um yeah and another thing um certain things like like Primitives","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1862s"},{"start_seconds":1869,"text":"so there's some interesting stuff going on right we use GHC core right we don't compile to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1869s"},{"start_seconds":1877,"text":"um like a machine language but what we want to do is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1877s"},{"start_seconds":1886,"text":"so it's it's basically we are doing things like create this fetch this Etc but","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1886s"},{"start_seconds":1895,"text":"if you think about how a normal compiler would generate all the instructions for the machine to be run on on how to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1895s"},{"start_seconds":1902,"text":"actually execute this right so otherwise you don't know what to do with it um but interestingly because Speedy The","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1902s"},{"start_seconds":1912,"text":"Interpreter living on the participant nodes has its own well will run its own things so rather","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1912s"},{"start_seconds":1920,"text":"than trying and generate a whole chunk of a left telling how to interact with the Ledger would just tells Speedy look at this point we're using a create","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1920s"},{"start_seconds":1929,"text":"and we literally gave it a magic token saying this is a primitive function which you know what to do with a GHC","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1929s"},{"start_seconds":1938,"text":"does not know what to do with and we will keep it in there right so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1938s"},{"start_seconds":1947,"text":"so this is when you see if you've ever seen magic you know someone's car this is why because this kind of magic is compiler doesn't understand it but Speedy does","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1947s"},{"start_seconds":1956,"text":"and it will make sense the moment Speedy actually looks at it right so let's let's look at a bit of practicalities","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1956s"},{"start_seconds":1964,"text":"here so say we started with a template T if one field being a party p","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1964s"},{"start_seconds":1972,"text":"with one choice C so how does this look like in our face when we're parsing so now we're going to try this is our demo","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1972s"},{"start_seconds":1979,"text":"and we're going to try and generate Haskell from it and we generate a data so a data type in high school","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1979s"},{"start_seconds":1987,"text":"but here so ignore the demo templates for now you can see the T again so T equals t p party so this is an almost direct","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1987s"},{"start_seconds":1995,"text":"translation but we use a type class and this is a demo template bit so the the data type it's not called demo template the data type is called t","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=1995s"},{"start_seconds":2003,"text":"and the demo templates uh arrow means there is a type class constraint on it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2003s"},{"start_seconds":2010,"text":"and this basically allows us later on to see which of these data types have","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2010s"},{"start_seconds":2018,"text":"the demo template restriction ah we need to do slump it's something slightly different when we're changing the core to LF","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2018s"},{"start_seconds":2027,"text":"so what's a choice so a choice interestingly because it's part of a template kind of takes implicitly a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2027s"},{"start_seconds":2035,"text":"template argument it's quite similar to how you would translate the object-oriented programming to a functional program actually you would","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2035s"},{"start_seconds":2043,"text":"normally take the this argument as a function argument so we have a choice an underscore choice on the course T underscore C","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2043s"},{"start_seconds":2051,"text":"which takes the template here than the choice C so C what is c c is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2051s"},{"start_seconds":2058,"text":"actually should be something like data C equals c right it's it's a trivial thing um and then we get an update event","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2058s"},{"start_seconds":2067,"text":"update so we don't directly get an ins we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2067s"},{"start_seconds":2078,"text":"actually have to update the lecture it's an update if you can obtain monads um I won't go into details of how that","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2078s"},{"start_seconds":2087,"text":"works but here again interface we can see one of the interesting translation bits so this is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2087s"},{"start_seconds":2096,"text":"um done","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2096s"},{"start_seconds":2098,"text":"using a functional dependency so there's a hap is anyone familiar with functional dependencies in high school","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2098s"},{"start_seconds":2106,"text":"no no okay right I'll intuitively explain it so we have basically it's a type","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2106s"},{"start_seconds":2115,"text":"inference mechanism which allows you to infer a type without you having to say anything","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2115s"},{"start_seconds":2124,"text":"um and basically what we are seeing with the has exercise type class if we have a","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2124s"},{"start_seconds":2130,"text":"template T in a choice C int is the is the only type that you","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2130s"},{"start_seconds":2137,"text":"will get right so there's a there's some coverage and I don't need to I won't go through it formally but basically if we","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2137s"},{"start_seconds":2145,"text":"know we have a template of type t a choice of type c we know that the result type will be end uniquely and this is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2145s"},{"start_seconds":2155,"text":"quite powerful I mean something you can't do in most languages so you hear you're using","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2155s"},{"start_seconds":2162,"text":"Haskell to encode a lot of this stuff which you wouldn't be able to encode directly otherwise you would have to manually output type signatures and stuff but we can actually encode it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2162s"},{"start_seconds":2169,"text":"within Haskell itself right we're basically encoding here types of the choices by using Haskell","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2169s"},{"start_seconds":2178,"text":"itself while still being within the Haskell lands and here exercise is not something we're going to","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2178s"},{"start_seconds":2186,"text":"properly translate into core it's going to be done by NF when it's actually being run on The","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2186s"},{"start_seconds":2193,"text":"Ledger okay yeah and I've already said this so the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2193s"},{"start_seconds":2199,"text":"demo templates it basically says that this is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2199s"},{"start_seconds":2206,"text":"a data type which represents a template so later on we can get it back","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2206s"},{"start_seconds":2214,"text":"okay and the Primitive will be replaced okay so pre-processing yeah at Prelude","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2214s"},{"start_seconds":2221,"text":"interestingly we remove unsupported language extensions so this is what I've talked about as well because like the new high school stuff we try to keep it","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2221s"},{"start_seconds":2229,"text":"to a relatively small area so people don't try and hack around um","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2229s"},{"start_seconds":2236,"text":"oh yeah our stuff is strict rather than lazy so we strictified as well yeah loads of other loads of other bits","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2236s"},{"start_seconds":2244,"text":"I'll try to go a little bit faster here so this is just GHC GHC type checks everything but since we're in Haskell","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2244s"},{"start_seconds":2252,"text":"lab now it's just general type checking as you see we'll do it uh but there is some interesting stuff here now right so we've taken our demo","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2252s"},{"start_seconds":2261,"text":"code we're now in high school lands but we've got demo code which is represented using some particular High School staff","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2261s"},{"start_seconds":2269,"text":"um but if we now throw errors the user will get Haskell Wireless that's pretty terrible isn't it yeah so there's actually where Dylan has done","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2269s"},{"start_seconds":2279,"text":"lots and lots of work and hope and we're actually planning to um have a bit more documentation on this as well so basically didn't have a lot","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2279s"},{"start_seconds":2287,"text":"of infrastructure work on the time Checker to make it easier to get errors which are not good for users and make","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2287s"},{"start_seconds":2295,"text":"them more demo specific um so I'm like here I think our team is happy to take feedback as well you know so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2295s"},{"start_seconds":2303,"text":"for example normally if you would say five equals to five you get like a quite you know like standard GC error saying","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2303s"},{"start_seconds":2310,"text":"intent string as types don't match because it actually equals in house class staff at the same types um so if mismatch similarly for exercise","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2310s"},{"start_seconds":2319,"text":"choice T we know that has to be an INT as I talked about through the functional dependency","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2319s"},{"start_seconds":2326,"text":"um that's not the string um so again a mismatch but this now means","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2326s"},{"start_seconds":2333,"text":"that let's go back a bit the user will go back an error which has this whole has exercise and t and c and","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2333s"},{"start_seconds":2341,"text":"ends and might mention a type class and now they go like I haven't written has exercise","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2341s"},{"start_seconds":2348,"text":"so you need to be a bit smarter so the hash choice is wrong it should be as exercise um and what we do basically GT is also","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2348s"},{"start_seconds":2357,"text":"quite flexible if it's error messages and like in a like how you program it in GHC and you can actually say for this type class when we get an error","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2357s"},{"start_seconds":2366,"text":"um actually say something else so we don't just say you know has exercise doesn't have an instance for TC and this","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2366s"},{"start_seconds":2373,"text":"time here or the constraints here don't match or something the user will have no clue about we instead say the choice is","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2373s"},{"start_seconds":2380,"text":"expecting this certain type uh for this particular template and this this error is handwritten by us","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2380s"},{"start_seconds":2390,"text":"um but interestingly because GHC is quite easy to modify it's not that deep into the code um we've tried to make it a bit easier","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2390s"},{"start_seconds":2397,"text":"to add new stuff so yeah custom errors um but yeah the problem is yeah okay oh","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2397s"},{"start_seconds":2405,"text":"I've got too much into this detail stuff","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2405s"},{"start_seconds":2408,"text":"um yeah so the the the the thing here is always it's about constraints type constraints seeing where they come from trying to get information of like you","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2408s"},{"start_seconds":2417,"text":"know what bit of demo did it refer to that's why we use the dowel uh interfaces sorry not the double interface the Haskell interfaces to say","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2417s"},{"start_seconds":2424,"text":"you know like double this was a template this was a choice Etc uh and then change it okay we'll just rush a bit through this","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2424s"},{"start_seconds":2433,"text":"um let's see type checking it's not too interesting here is where it's more interesting","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2433s"},{"start_seconds":2440,"text":"so conversion so we've gone through jdc we have core","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2440s"},{"start_seconds":2447,"text":"um this core has just Haskell but has Type classes of high school which we know the meaning of and GHC","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2447s"},{"start_seconds":2455,"text":"does not right we know that demo template as a type class kind of","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2455s"},{"start_seconds":2463,"text":"secretly means this was originally a demo template so the moment we've now gone to or actually time where we want","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2463s"},{"start_seconds":2471,"text":"to convert core to a left we can remember this information because it will be in the type and then we can do","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2471s"},{"start_seconds":2478,"text":"something slightly smarter just for this and get back our stuff yeah but again like I said the interesting","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2478s"},{"start_seconds":2487,"text":"bit is we have not adapted to GHC core right","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2487s"},{"start_seconds":2495,"text":"okay um yeah so try to combine it all again and this is kind of like how you might","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2495s"},{"start_seconds":2502,"text":"roughly send it over and I think let's see this is a little","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2502s"},{"start_seconds":2510,"text":"bit this is gonna get okay so yes we've done the single compile single module stuff","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2510s"},{"start_seconds":2518,"text":"all demo left and then we combine this into a single dollar that's kind of where it ends up running away from the end","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2518s"},{"start_seconds":2525,"text":"thank you interface files are very similar to Haskell interfaces don't know exactly what is in there","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2525s"},{"start_seconds":2534,"text":"um but the trick is it's used for incremental compilation right so the idea is we don't we we can just use look","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2534s"},{"start_seconds":2542,"text":"like a like the answer uh answer the Ian's question it has representations of","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2542s"},{"start_seconds":2550,"text":"the types in a kind of compiled form which you can refer to so as long as we know that the source file hasn't changed we can just look at the interface file rather than recompile the whole thing","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2550s"},{"start_seconds":2559,"text":"again um and that's why are those those are the dot the different extensions that you see inside a package you've got like","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2559s"},{"start_seconds":2565,"text":"the yeah the H is it hia or something yeah yeah yeah yeah yeah yeah yeah yeah exactly exactly because you","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2565s"},{"start_seconds":2574,"text":"don't have to have those right um I'm not fully sure if you don't have yeah I mean if you have to you you might","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2574s"},{"start_seconds":2582,"text":"need them if you don't have the original them all right um but I'm not sure about this","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2582s"},{"start_seconds":2590,"text":"because I couldn't see the documentation what those thoughts because I was looking inside the package tonight I couldn't see what these files were for so this is interesting to know okay okay","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2590s"},{"start_seconds":2601,"text":"what does hia stat is hia isn't it so I think it's ah I know H I would just have to worry","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2601s"},{"start_seconds":2609,"text":"yeah it's always High School interface okay got it um I always like object","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2609s"},{"start_seconds":2618,"text":"um and I think there's some a file so there's also the seven libraries as well and this is the function which actually serializes the whole thing","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2618s"},{"start_seconds":2626,"text":"um interesting bits I suppose just a domino left the dependencies","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2626s"},{"start_seconds":2633,"text":"the directory or the module dependencies oh yeah everybody spoke yeah I don't really have time to do that but it's","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2633s"},{"start_seconds":2641,"text":"also data dependencies right so the source dependencies there's also data dependencies where you just refer to the dart we support that as well","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2641s"},{"start_seconds":2649,"text":"but the semantics of that are a bit tricky oh yeah near the interface of us so yeah I'll go a bit quicker for this","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2649s"},{"start_seconds":2657,"text":"folks I I have less knowledge to chance as well so here testing which I've already gone through larger mostly of that so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2657s"},{"start_seconds":2665,"text":"but there's some interesting bits about dlf so we can actually extract test names back from the produced LF","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2665s"},{"start_seconds":2672,"text":"um yeah let's go for this so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2672s"},{"start_seconds":2680,"text":"yeah so maybe just to give a bit more info so here","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2680s"},{"start_seconds":2687,"text":"yeah I've kind of been kind of wondering what something's what to do so basically what has happened is we've done a lot of work previously as a team to develop","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2687s"},{"start_seconds":2694,"text":"things like GNC ID which allows us to basically have the whole damage to your thing which gives you type information","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2694s"},{"start_seconds":2701,"text":"Etc but this is kind of Open Source externally evolved into the Haskell language server","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2701s"},{"start_seconds":2710,"text":"um which works with PS codes so but now kind of the well while with GHC we're stuck in an old version but fine you","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2710s"},{"start_seconds":2719,"text":"know it's more obvious how to shift here the the world has changed more underneath of us so it's a bit of an","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2719s"},{"start_seconds":2726,"text":"interesting problem here as well well so so you mean comparing the Haskell um so language server compared to the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2726s"},{"start_seconds":2735,"text":"download language search yeah so the stock we use is basically ask a language server like we okay yes we're stuck in an old version of Haskell language so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2735s"},{"start_seconds":2744,"text":"yes yeah we're basically using this stuff rewrite and open sourced and and the community and right","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2744s"},{"start_seconds":2750,"text":"but then within demo Studio we have some stuff which allows you to again make it that more specific right yeah","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2750s"},{"start_seconds":2758,"text":"that's kind of the right so it's quite a good design in the sense that most of our stuff is still for Haskell and we try to not","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2758s"},{"start_seconds":2767,"text":"change things too much so we can kind of stay within hospital and and keep the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2767s"},{"start_seconds":2774,"text":"updates but now because ghcid has changed quite a lot it's a little bit harder we'll have to see about what to do there but","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2774s"},{"start_seconds":2783,"text":"um um yeah okay I think that's fine","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2783s"},{"start_seconds":2793,"text":"cool thank you thank you bass that was really interesting and certainly helped my get a lot straighter in my head the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2793s"},{"start_seconds":2801,"text":"relationship between damel and Haskell in particular yeah it's I think it's a Testament of","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2801s"},{"start_seconds":2808,"text":"the Haskell language and the GDC compiler the fact that we're able to do a lot of this without a ridiculous amount of pain","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2808s"},{"start_seconds":2816,"text":"um I would say but it has its downsides of course that the the haskellisms and the ghcisms kind of leak through to the","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2816s"},{"start_seconds":2825,"text":"user sometimes and that is something my team tries to actively tackle like I said with the type errors Dylan has been working on and it's something we also have to take","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2825s"},{"start_seconds":2834,"text":"feedback on because it is something we're still planning work for the next half Year again to improve type errors and document a bit more about so any","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2834s"},{"start_seconds":2842,"text":"feedback on this is more than welcome sure well no thank you this was great it reminds me some","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2842s"},{"start_seconds":2850,"text":"really old errors and challenges and when Neil was here the discussions we had","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2850s"},{"start_seconds":2857,"text":"okay cool brought back some old memories","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2857s"},{"start_seconds":2866,"text":"what's your sort of primary things that you're focusing on now in in the team to improve","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2866s"},{"start_seconds":2874,"text":"so okay so it didn't it's going to continue with a lot of improvements in the IDE","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2874s"},{"start_seconds":2882,"text":"and anti-bearers but one of the main things is going to be upgrades so um the the biggest feature is we're","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2882s"},{"start_seconds":2890,"text":"going to look at how to have a quite minimal version of upgrades a proof of Concepts sorry do you mean upgrading upgrading and upgrading the customer's","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2890s"},{"start_seconds":2900,"text":"code or do you mean upgrading as an upgrading um to a new version of SDK or do you mean upgrading","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2900s"},{"start_seconds":2908,"text":"customer code yeah yeah right so like for example adding a field through your template or something yeah","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2908s"},{"start_seconds":2915,"text":"or updating a choice um like the the body right uh and we're gonna have quite restricted version of","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2915s"},{"start_seconds":2923,"text":"that at first but that's that's one thing we want to work we're planning to work on first um yeah","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2923s"},{"start_seconds":2931,"text":"and one of the main things we're going to support hopefully work on first is how to look at um the whole package management story of","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2931s"},{"start_seconds":2938,"text":"this and how to do this and cancel all the package fitting and kind of do that in a nice way and only then look a bit more on what actually a sport than","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2938s"},{"start_seconds":2947,"text":"language so we're basically going to try and get most of the mechanics in and and and let customers be able to do it and then follow on on how to actually think","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2947s"},{"start_seconds":2956,"text":"more about where to allow flexibility and why not um","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2956s"},{"start_seconds":2962,"text":"it's a tricky problem right","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2962s"},{"start_seconds":2972,"text":"cool okay I think there are more questions about us so say thank you very much again I will be sharing this with the wider TSC team as well so","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2972s"},{"start_seconds":2981,"text":"um in conclusion thank you very much for time it's been a really good session I've certainly really enjoyed that and learned a lot so thank you okay yeah and thanks for asking me as well","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2981s"},{"start_seconds":2989,"text":"um please do share the video with me as well and I'd love to think yeah yeah and then if you want to chat wider as well of course you can all right great well","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2989s"},{"start_seconds":2997,"text":"thank you for watching","url":"https://www.youtube.com/watch?v=QIHRD45eRHg&t=2997s"}],"youtube_url":"https://youtube.com/watch?v=QIHRD45eRHg","url":"https://ccpedia.xyz/videos/QIHRD45eRHg"}